In Git, and most other <a rel="nofollow" target="_blank" href="https://en.wikipedia.org/wiki/Version_control">VCS</a> tools, branching is one of the main constructs that really make it useful for software development. These branches are almost like a new copy of your code at the current state, which can then be used to develop new code.
For example, whenever you need to create a new feature, fix a bug, or rewrite any of your code, it's a good idea to create a new branch so that none of your changes affect the &quot;master&quot; version of the code. This is important since it can be very difficult to revert code changes from memory, especially in complex systems.
There are a few ways you can create new branches in Git, with many of them differing in how your branch is created from the main branch, whether it be from your current branch, a different branch, a tag, etc.
The most common way to create a new branch is the following:
<pre><code class="hljs">$ git checkout -b &lt;branch-name&gt;
</code></pre>
This is most commonly used because it will create the branch for you from your current branch and it will switch you to that branch in a single command.
You can also optionally specify a different branch from which the new one will be created:
<pre><code class="hljs">$ git checkout -b new-branch dev-branch
Switched to branch &#x27;new-branch&#x27;
</code></pre>
Another common way is by using the <code>branch</code> command directly (which <code>checkout</code> does behind the scenes):
<pre><code class="hljs">$ git branch &lt;branch-name&gt;
</code></pre>
However, as you can see from the following example, this doesn't automatically switch us over to the new branch and keeps us on our current one:
<pre><code class="hljs">$ git branch
* master
$ git branch new-branch
$ git branch
* master
 new-branch
</code></pre>
If you want to work on the branch immediately then you'll need to switch to it manually using the <code>checkout</code> command:
<pre><code class="hljs">$ git checkout new-branch
Switched to branch &#x27;new-branch&#x27;
</code></pre>
<h2 id="creatingabranchfromacommit">Creating a Branch from a Commit</h2>
As mentioned above, there are a few other ways you can create new branches. One of those ways is by specifying a specific commit via its hash:
<pre><code class="hljs">$ git branch &lt;branch-name&gt; &lt;hash&gt;
</code></pre>
As always with Git, the entire hash doesn't actually need to be specified, just a few characters.
<pre><code class="hljs">$ git branch
* master
$ git branch commit-branch 735c5b4
$ git branch
 commit-branch
* master
</code></pre>
You can also use the <code>git checkout -b &lt;branch-name&gt; &lt;hash&gt;</code> syntax, which will create the branch and check it out, all in one command.
<h2 id="creatingabranchfromatag">Creating a Branch from a Tag</h2>
Much like creating a branch from a commit, you can also create a branch from a tag. This is especially useful since tags are, in my opinion, a better way to reference a certain point in a project's history.
So if you have created tags throughout your project's history, you can create a new branch just like before, but with a tag as the identifier.
<pre><code class="hljs">$ git branch tag-branch v0.4.12
$ git branch
 tag-branch
* master
</code></pre>
And again, the <code>git checkout -b &lt;branch-name&gt; &lt;tag&gt;</code> syntax can also be used.

Scott Robinson

Git: Create a New Branch

Shadab Ansari

Building a Todo App with Flask in Python

Dan Nelson

Multiple Linear Regression with Python

Marcus Sanatan

Introduction to Phaser 3: Building Breakout

Vladimir Batoćanin

Mathematical Proof of Algorithm Correctness and Efficiency

<h2 id="introduction">Introduction</h2>
Computing has evolved over time and more and more ways have come up to make computers run even faster. What if instead of executing a single instruction at a time, we can also execute several instructions at the same time? This would mean a significant increase in the performance of a system.
Through concurrency, we can achieve this and our Python programs will be able to handle even more requests at a single time, and over time leading to impressive performance gains.
In this article, we will discuss concurrency in the context of Python programming, the various forms it comes in and we will speed up a simple program in order to see the performance gains in practice.
<h2 id="whatisconcurrency">What is Concurrency?</h2>
When two or more events are concurrent, it means that they are happening at the same time. In real life, concurrency is common since a lot of things happen at the same time all the time. In computing, things are a bit different when it comes to concurrency.
In computing, concurrency is the execution of pieces of work or tasks by a computer at the same time. Normally, a computer executes a piece of work as others wait their turn, once it is completed, the resources are freed and the next piece of work begins execution. This is not the case when concurrency is implemented as the pieces of work to be executed don't always have to wait for others to be completed. They are executed at the same time.
<h2 id="concurrencyvsparallelism">Concurrency vs Parallelism</h2>
We have defined concurrency as the execution of tasks at the same time, but how does it compare to <a target="_blank" href="/parallel-processing-in-python/">parallelism</a>, and what is it?
Parallelism is achieved when multiple computations or operations are carried out at the same time or in parallel with the goal of speeding up the computation process.
Both concurrency and parallelism are involved with performing multiple tasks simultaneously, but what sets them apart is the fact that while concurrency only takes place in one processor, parallelism is achieved through utilizing multiple CPUs to have tasks done in parallel.
<h2 id="threadvsprocessvstask">Thread vs Process vs Task</h2>
While generally speaking, threads, processes, and tasks may refer to pieces or units of work. However, in detail they are not so similar.
A thread is the smallest unit of execution that can be performed on a computer. Threads exist as parts of a process and are usually not independent of each other, meaning they share data and memory with other threads within the same process. Threads are also sometimes referred to as lightweight processes.
For example, in a document processing application, one thread could be responsible for formatting the text and another handles the auto-saving, while another is doing spell checks.
A process is a job or an instance of a computed program that can be executed. When we write and execute code, a process is created to execute all the tasks that we have instructed the computer to do through our code. A process can have a single primary thread or have several threads within it, each with its own stack, registers, and program counter. But they all share the code, data, and memory.
Some of the common differences between processes and threads are:
<ul>
<li>Processes work in isolation while threads can access the data of other threads</li>
<li>If a thread within a process is blocked, other threads can continue executing, while a blocked process will put on hold the execution of the other processes in the queue</li>
<li>While threads share memory with other threads, processes do not and each process has its own memory allocation.</li>
</ul>
A task is simply a set of program instructions that are loaded in memory.
<h2 id="multithreadingvsmultiprocessingvsasyncio">Multithreading vs Multiprocessing vs Asyncio</h2>
Having explored threads and processes, let us now delve deeper into the various ways a computer executes concurrently.
Multithreading refers to the ability of a CPU to execute multiple threads concurrently. The idea here is to divide a process into various threads that can be executed in a parallel manner or at the same time. This division of duty enhances the speed of execution of the entire process. For example, in a word processor like MS Word, a lot of things are going on when in use.
Multithreading will allow the program to auto-save the content being written, perform spell checks for the content, and also format the content. Through multithreading, all this can take place simultaneously and the user does not have to complete the document first for the saving to happen or the spell checks to take place.
Only one processor is involved during multithreading and the operating system decides when to switch tasks in the current processor, these tasks may be external to the current process or program being executed in our processor.
Multiprocessing, on the other hand, involves utilizing two or more processor units on a computer to achieve parallelism. Python implements multiprocessing by creating different processes for different programs, with each having its own instance of the Python interpreter to run and memory allocation to utilize during execution.
<a rel="nofollow" target="_blank" href="https://docs.python.org/3/library/asyncio.html">AsyncIO</a> or asynchronous IO is a new paradigm introduced in Python 3 for the purpose of writing concurrent code by using the <a target="_blank" href="/python-async-await-tutorial/">async/await</a> syntax. It is best for IO-bound and high-level networking purposes.
<h2 id="whentouseconcurrency">When to use Concurrency</h2>
The advantages of concurrency are best tapped into when solving CPU-bound or IO-bound problems.
CPU-bound problems involve programs that do a lot of computation without requiring networking or storage facilities and are only limited by capabilities of the CPU.
IO-bound problems involve programs that rely on input/output resources which sometimes may be slower than the CPU and are usually in use, therefore, the program has to wait for the current task to release the I/O resources.
It is best to write concurrent code when the CPU or I/O resources are limited and you want to speed up your program.
<h2 id="howtouseconcurrency">How to use Concurrency</h2>
In our demonstration example, we will solve a common I/O bound problem, which is downloading files over a network. We will write non-concurrent code and concurrent code and compare the time taken for each program to complete.
We will download images from <a rel="nofollow" target="_blank" href="http://imgur.com/">Imgur</a> through their API. First, we need to create an account and then <a rel="nofollow" target="_blank" href="https://api.imgur.com/oauth2/addclient">register</a> our demo application in order to access the API and download some images.
Once our application is set up on Imgur, we will receive a client identifier and client secret that we'll use to access the API. We'll save the credentials in a <code>.env</code> file since Pipenv <a rel="nofollow" target="_blank" href="https://pipenv.readthedocs.io/en/latest/advanced/#automatic-loading-of-env">automatically loads</a> the variables from the <code>.env</code> file.
<h3 id="synchronousscript">Synchronous Script</h3>
With those details, we can create our first script that will simply download a bunch of images to a <code>downloads</code> folder:
<pre><code class="hljs">import os
from urllib import request
from imgurpython import ImgurClient
import timeit

client_secret = os.getenv(&quot;CLIENT_SECRET&quot;)
client_id = os.getenv(&quot;CLIENT_ID&quot;)

client = ImgurClient(client_id, client_secret)

def download_image(link):
 filename = link.split(&#x27;/&#x27;)[3].split(&#x27;.&#x27;)[0]
 fileformat = link.split(&#x27;/&#x27;)[3].split(&#x27;.&#x27;)[1]
 request.urlretrieve(link, &quot;downloads/{}.{}&quot;.format(filename, fileformat))
 print(&quot;{}.{} downloaded into downloads/ folder&quot;.format(filename, fileformat))

def main():
 images = client.get_album_images(&#x27;PdA9Amq&#x27;)
 for image in images:
 download_image(image.link)

if __name__ == &quot;__main__&quot;:
 print(&quot;Time taken to download images synchronously: {}&quot;.format(timeit.Timer(main).timeit(number=1)))
</code></pre>
In this script, we pass an Imgur album identifier and then download all the images in that album using the function <code>get_album_images()</code>. This gives us a list of the images and then we use our function to download the images and save them to a folder locally.
This simple example gets the job done. We are able to download images from Imgur but it does not work concurrently. It only downloads one image at a time before moving on to the next image. On my machine, the script took 48 seconds to download the images.
<h3 id="optimizingwithmultithreading">Optimizing with Multithreading</h3>
Let us now make our code concurrent using Multithreading and see how it performs:
<pre><code class="hljs"># previous imports from synchronous version are maintained
import threading
from concurrent.futures import ThreadPoolExecutor

# Imgur client setup remains the same as in the synchronous version

# download_image() function remains the same as in the synchronous

def download_album(album_id):
 images = client.get_album_images(album_id)
 with ThreadPoolExecutor(max_workers=5) as executor:
 executor.map(download_image, images)

def main():
 download_album(&#x27;PdA9Amq&#x27;)

if __name__ == &quot;__main__&quot;:
 print(&quot;Time taken to download images using multithreading: {}&quot;.format(timeit.Timer(main).timeit(number=1)))
</code></pre>
In the above example, we create a <code>Threadpool</code> and set up 5 different threads to download images from our gallery. Remember threads execute on a single processor.
This version of our code takes 19 seconds. That is almost three times faster than the synchronous version of the script.
<h3 id="optimizingwithmultiprocessing">Optimizing with Multiprocessing</h3>
Now we will implement Multiprocessing over several CPUs for the same script to see how it performs:
<pre><code class="hljs"># previous imports from synchronous version remain
import multiprocessing

# Imgur client setup remains the same as in the synchronous version

# download_image() function remains the same as in the synchronous

def main():
 images = client.get_album_images(&#x27;PdA9Amq&#x27;)

 pool = multiprocessing.Pool(multiprocessing.cpu_count())
 result = pool.map(download_image, [image.link for image in images])

if __name__ == &quot;__main__&quot;:
 print(&quot;Time taken to download images using multiprocessing: {}&quot;.format(timeit.Timer(main).timeit(number=1)))
</code></pre>
In this version, we create a pool that contains the number of CPU cores on our machine and then map our function to download the images across the pool. This makes our code run in a parallel manner across our CPU and this multiprocessing version of our code takes an average of 14 seconds after multiple runs.
This is slightly faster than our version that utilizes threads and significantly faster than our non-concurrent version.
<h3 id="optimizingwithasyncio">Optimizing with AsyncIO</h3>
Let us implement the same script using AsyncIO to see how it performs:
<pre><code class="hljs"># previous imports from synchronous version remain
import asyncio
import aiohttp

# Imgur client setup remains the same as in the synchronous version

async def download_image(link, session):
 &quot;&quot;&quot;
 Function to download an image from a link provided.
 &quot;&quot;&quot;
 filename = link.split(&#x27;/&#x27;)[3].split(&#x27;.&#x27;)[0]
 fileformat = link.split(&#x27;/&#x27;)[3].split(&#x27;.&#x27;)[1]

 async with session.get(link) as response:
 with open(&quot;downloads/{}.{}&quot;.format(filename, fileformat), &#x27;wb&#x27;) as fd:
 async for data in response.content.iter_chunked(1024):
 fd.write(data)

 print(&quot;{}.{} downloaded into downloads/ folder&quot;.format(filename, fileformat))

async def main():
 images = client.get_album_images(&#x27;PdA9Amq&#x27;)

 async with aiohttp.ClientSession() as session:
 tasks = [download_image(image.link, session) for image in images]

 return await asyncio.gather(*tasks)

if __name__ == &quot;__main__&quot;:
 start_time = timeit.default_timer()

 loop = asyncio.get_event_loop()
 results = loop.run_until_complete(main())

 time_taken = timeit.default_timer() - start_time

 print(&quot;Time taken to download images using AsyncIO: {}&quot;.format(time_taken))
</code></pre>
There are few changes that stand out in our new script. First, we no longer use the normal <code>requests</code> module to download our images, but instead we use <code>aiohttp</code>. The reason for this is that <code>requests</code> is incompatible with AsyncIO since it uses Python's <code>http</code> and <code>sockets</code> module.
Sockets are blocking by nature, i.e. they cannot be paused and execution continues later on. <code>aiohttp</code> solves this and helps us achieve truly asynchronous code.
The keyword <code>async</code> indicates that our function is a coroutine (Co-operative Routine), which is a piece of code that can be paused and resumed. Coroutines multi-task cooperatively, meaning they choose when to pause and let others execute.
We create a pool where we make a queue of all the links to the images we wish to download. Our coroutine is started by putting it in the event loop and executing it until completion.
After several runs of this script, the AsyncIO version takes 14 seconds on average to download the images in the album. This is significantly faster than the multi-threaded and synchronous versions of the code, and pretty similar to the multiprocessing version.
<h2 id="performancecomparison">Performance Comparison</h2>
<table class="table table-striped" style="font-size:15px;overflow-x:auto;">
<thead>
 <tr>
 <th>Synchronous</th>
 <th>Multithreading</th>
 <th>Multiprocessing</th>
 <th>Asyncio</th>
 </tr>
</thead>
<tbody>
 <tr>
 <td>48s</td>
 <td>19s</td>
 <td>14s</td>
 <td>14s</td>
 </tr>
</tbody>
</table>
<h2 id="conclusion">Conclusion</h2>
In this post, we have covered concurrency and how it compares to parallelism. We have also explored the various methods that we can use to implement concurrency in our Python code, including multithreading and multiprocessing, and also discussed their differences.
From the examples above, we can see how concurrency helps our code run faster than it would in a synchronous manner. As a rule of thumb, Multiprocessing is best suited for CPU-bound tasks while Multithreading is best for I/O-bound tasks.
The source code for this post is available on <a rel="nofollow" target="_blank" href="https://github.com/ro6ley/python-concurrency-example">GitHub</a> for reference.

Robley Gori

Concurrency in Python

Guest Contributor

Getting Started with Python's Wikipedia API

<h2 id="introduction">Introduction</h2>
Email is one of the most used tools for communication in web applications because it helps you reach your users directly, build your brand, or send general notifications.
So, you are thinking about sending emails from your next great Node.js application. You are in the right place!
In this tutorial you'll learn how to send emails with HTML content and attachments using the <a rel="nofollow" target="_blank" href="https://nodemailer.com/">nodemailer</a> module, as well as set up <a rel="nofollow" target="_blank" href="https://mailtrap.io/">Mailtrap</a>, a fake SMTP server, for testing your code.
<h2 id="prerequisites">Prerequisites</h2>
To follow along, you will need to have <a rel="nofollow" target="_blank" href="https://nodejs.org/en/">Node.js</a> and <a rel="nofollow" target="_blank" href="https://www.npmjs.com/">npm</a> (Node Package Manager) installed locally.
To test sending emails from a local development machine, without having to configure a server, we will be using Mailtrap.
<h2 id="gettingstarted">Getting Started</h2>
There are many Node.js modules for sending emails. Amongst them, <code>nodemailer</code> is the most popular choice. It is a module that gives you the ability to easily send emails without hassle.
Let's go ahead and create a new folder and a new <code>package.json</code> file with the <code>npm init</code> command:
<pre><code class="hljs">$ mkdir nodejs-email
$ cd nodejs-email
$ npm init -y
</code></pre>
The <code>-y</code> flag provided will skip the step-by-step tool to scaffold out your project.
Now let's install the <code>nodemailer</code> module using <code>npm</code>:
<pre><code class="hljs">$ npm install nodemailer
</code></pre>
With the model ready for use, let's create an <code>index.js</code> file in our project directory.
In Node.js, the <code>require</code> syntax is used to load modules in to your code:
<pre><code class="hljs">const nodemailer = require(&#x27;nodemailer&#x27;);
</code></pre>
<h2 id="usingsmtpfornodemailertransport">Using SMTP for Nodemailer Transport</h2>
The <a rel="nofollow" target="_blank" href="https://en.wikipedia.org/wiki/Simple_Mail_Transfer_Protocol">Simple Mail Transfer Protocol</a> (SMTP) is a protocol for sending e-mail messages between servers. Most e-mail systems that send mail over the Internet support SMTP based sending.
And guess what? SMTP is the main transport used by <code>nodemailer</code> for delivering messages.
Creating a <code>nodemailer</code> transport is as easy as calling the following method with a few parameters:
<pre><code class="hljs">let transport = nodemailer.createTransport(options[, defaults])
</code></pre>
However, to actually send a message through our transport, we have to configure the connection first.
<h2 id="testingourcodewithmailtrap">Testing our Code with Mailtrap</h2>
Mailtrap is a &quot;fake SMTP server&quot; used for development purposes. Instead of having to test your code with your own email account, and potentially flooding your inbox with test emails, you can instead use Mailtrap as the endpoint.
Create a new account on Mailtrap if you don't already have one, and then create a new inbox and get your credentials:
<img src="https://stackabuse.s3.amazonaws.com/media/how-to-send-an-email-with-node-js-1.png" alt="">
Now, all we need to do is put the credentials into <code>nodemailer</code>'s transport object:
<pre><code class="hljs">let transport = nodemailer.createTransport({
 host: &#x27;smtp.mailtrap.io&#x27;,
 port: 2525,
 auth: {
 user: &#x27;put_your_username_here&#x27;,
 pass: &#x27;put_your_password_here&#x27;
 }
});
</code></pre>
With all of that set up, we can go ahead and send our first test email:
<pre><code class="hljs">const message = {
 from: &#x27;elonmusk@tesla.com&#x27;, // Sender address
 to: &#x27;to@email.com&#x27;, // List of recipients
 subject: &#x27;Design Your Model S | Tesla&#x27;, // Subject line
 text: &#x27;Have the most fun you can in a car. Get your Tesla today!&#x27; // Plain text body
};
transport.sendMail(message, function(err, info) {
 if (err) {
 console.log(err)
 } else {
 console.log(info);
 }
});
</code></pre>
Ta-da, that's it!
<img src="https://stackabuse.s3.amazonaws.com/media/how-to-send-an-email-with-node-js-2.png" alt="">
<h2 id="sendinganhtmlemail">Sending an HTML Email</h2>
While the previous example does the job just fine, it's what some may call &quot;boring&quot;.
Nowadays, emails tend to be styled, colorful, with big buttons and exciting and engaging visuals. To achieve this, we embed HTML into our emails.
You can create these HTML emails and send them with <code>nodemailer</code> just as easily as you could send a plain text email. All it takes is to use the <code>html</code> parameter in the <code>message</code> object instead of <code>text</code>:
<pre><code class="hljs">const message = {
 from: &#x27;elonmusk@tesla.com&#x27;,
 to: &#x27;to@email.com&#x27;,
 subject: &#x27;Design Your Model S | Tesla&#x27;,
 html: &#x27;&lt;h1&gt;Have the most fun you can in a car!&lt;/h1&gt;&lt;p&gt;Get your &lt;b&gt;Tesla&lt;/b&gt; today!&lt;/p&gt;&#x27;
};
</code></pre>
Although this example is quite simple, only including a <code>&lt;h1&gt;</code>, <code>&lt;p&gt;</code>, and <code>&lt;b&gt;</code> tag, you can include much, much more.
Voilà!
<img src="https://stackabuse.s3.amazonaws.com/media/how-to-send-an-email-with-node-js-3.png" alt="">
Keep in mind that you can also send both HTML and plain text in a single email by providing both parameters. With both versions in your email message, the recipient's email client can then choose which one to display.
<h2 id="sendingemailwithanattachment">Sending Email with an Attachment</h2>
There are countless reasons why you might want to include an attachment in your email, like sending pictures, spreadsheets for work, or videos.
As another example, if you run an e-commerce website, for example, you might want to send receipts to your customers:
<pre><code class="hljs">const nodemailer = require(&quot;nodemailer&quot;);

let transport = nodemailer.createTransport({
 // ...
});

const message = {
 from: &#x27;elonmusk@tesla.com&#x27;,
 to: &#x27;to@email.com&#x27;,
 subject: &#x27;Design Your Model S | Tesla&#x27;,
 html: &#x27;&lt;h1&gt;Have the most fun you can in a car!&lt;/h1&gt;&lt;p&gt;Get your &lt;b&gt;Tesla&lt;/b&gt; today!&lt;/p&gt;&#x27;,
 attachments: [
 { // Use a URL as an attachment
 filename: &#x27;your-testla.png&#x27;,
 path: &#x27;https://media.gettyimages.com/photos/view-of-tesla-model-s-in-barcelona-spain-on-september-10-2018-picture-id1032050330?s=2048x2048&#x27;
 }
 ]
};
transport.sendMail(message, function (err, info) {
 // ...
 });
</code></pre>
<img src="https://stackabuse.s3.amazonaws.com/media/how-to-send-an-email-with-node-js-4.png" alt="">
And you can use a file on disk as an attachment too. They don't need to be web-based.
<h2 id="conclusion">Conclusion</h2>
You can now easily send personalized emails in your Node.js code using the <code>nodemailer</code> module. And don't forget, the <code>nodemailer</code> <a rel="nofollow" target="_blank" href="https://nodemailer.com/about/">documentation</a> is your best friend for learning about the more advanced options.

How to Send Emails with Node.js

This article is the third in a series on working with PDFs in Python:
<ul>
<li><a target="_blank" href="/working-with-pdfs-in-python-adding-images-and-watermarks/">Reading and Splitting Pages</a></li>
<li><a target="_blank" href="/working-with-pdfs-in-python-adding-images-and-watermarks/">Adding Images and Watermarks</a></li>
<li>Inserting, Deleting, and Reordering Pages (you are here)</li>
</ul>
<h2 id="introduction">Introduction</h2>
This article is part three of a little series on working with PDFs in Python. In the previous articles we gave an introduction into reading PDF documents using Python. So far you have learned how to manipulate existing PDFs, and to read and extract the content - both text and images. Furthermore, we have discussed splitting documents into its single pages, as well as adding watermarks and barcodes.
Now in this article we will go one step further and demonstrate how to rearrange a PDF document in a few different ways.
<ul>
<li><a href="#deletingpageswithpdfrw">Deleting Pages with pdfrw</a></li>
<li><a href="#deletingpageswithpymupdf">Deleting Pages with PyMuPDF</a></li>
<li><a href="#insertingpageswithpymupdf">Inserting Pages with PyMuPDF</a></li>
<li><a href="#splittingevenandoddpageswithpypdf2">Splitting Even and Odd Pages with PyPDF2</a></li>
</ul>
<h2 id="deletingpageswithpdfrw">Deleting Pages with <code>pdfrw</code></h2>
Deleting individual pages from a PDF file is as simple as the following:
<ul>
<li>Read a PDF as an input file</li>
<li>Write selected pages to a new PDF as an output file</li>
</ul>
The following example removes the first two pages from a PDF document. Using the <a rel="nofollow" target="_blank" href="https://pypi.org/project/pdfrw/">pdfrw</a> library, the file is read with the help of the <code>PdfReader()</code> class first. Except for both the first and second page, each page is added to the output file using the <code>addpage()</code> method, and then written to disk eventually.
Figure 1 shows the output when executing the code on a four-page PDF file.
<pre><code class="hljs"># !/usr/bin/python
# Remove the first two pages (cover sheet) from the PDF

from pdfrw import PdfReader, PdfWriter

input_file = &quot;example.pdf&quot;
output_file = &quot;example-updated.pdf&quot;

# Define the reader and writer objects
reader_input = PdfReader(input_file)
writer_output = PdfWriter()

# Go through the pages one after the next
for current_page in range(len(reader_input.pages)):
 if current_page &gt; 1:
 writer_output.addpage(reader_input.pages[current_page])
 print(&quot;adding page %i&quot; % (current_page + 1))

# Write the modified content to disk
writer_output.write(output_file)
</code></pre>
<img class="img-responsive" alt="Delete the first two pages from a PDF" src="https://stackabuse.s3.amazonaws.com/media/working-with-pdfs-python-inserting-deleting-reordering-pages-1.png">
<h2 id="deletingpageswithpymupdf">Deleting Pages with PyMuPDF</h2>
The <a rel="nofollow" target="_blank" href="https://pypi.org/project/PyMuPDF/">PyMuPDF</a> library comes with quite a few sophisticated methods that simplify deleting pages from a PDF file. It allows you to specify either a single page (using the <code>deletePage()</code> method), or a range of page numbers (using the <code>deletePageRange()</code> method), or a list with the page numbers (using the <code>select()</code> method).
The following example will demonstrate how to use a list in order to select the pages to keep from the original document. Be aware that the pages that are not specified will not be part of the output document. In our case the output document contains the first, second, and fourth pages only.
<pre><code class="hljs"># !/usr/bin/python

# Recall that PyMuPDF is imported as fitz
import fitz

input_file = &quot;example.pdf&quot;
output_file = &quot;example-rearranged.pdf&quot;

# Define the pages to keep - 1, 2 and 4
file_handle = fitz.open(input_file)
pages_list = [0,1,3]

# Select the pages and save the output
file_handle.select(pages_list)
file_handle.save(output_file)
</code></pre>
<h2 id="insertingpageswithpymupdf">Inserting Pages with PyMuPDF</h2>
The <code>PyMuPDF</code> library allows you to insert pages as well. It provides the methods <code>newPage()</code> for adding completely blank pages, and <code>insertPage()</code> in order to add an existing page. The next example shows how to add a page from a different PDF document at the end of another one.
<pre><code class="hljs"># !/usr/bin/python

# Recall that PyMuPDF is imported as fitz
import fitz

original_pdf_path = &quot;example.pdf&quot;
extra_page_path = &quot;extra-page.pdf&quot;
output_file_path = &quot;example-extended.pdf&quot;

original_pdf = fitz.open(original_pdf_path)
extra_page = fitz.open(extra_page_path)

original_pdf.insertPDF(extra_page)
original_pdf.save(output_file_path)
</code></pre>
<h2 id="splittingevenandoddpageswithpypdf2">Splitting Even and Odd Pages with PyPDF2</h2>
The following example uses <a rel="nofollow" target="_blank" href="https://pypi.org/project/PyPDF2/">PyPDF2</a> and does this by taking a file, separating it into its even and odd pages, saving the even pages in the file <code>even.pdf</code>, and the odd pages in <code>odd.pdf</code>.
This Python script starts with the definition of two output files, <code>even.pdf</code> and <code>odd.pdf</code>, as well as their corresponding writer objects <code>pdf_writer_even</code> and <code>pdf_writer_odd</code>. Next, in a for-loop the script goes through the entire PDF file, and reads one page after the other. Pages with even page numbers are added to the stream <code>pdf_writer_even</code> using <code>addPage()</code>, and odd numbers are added to the stream <code>pdf_writer_odd</code>. At the end the two streams are saved to disk in separate files, as defined before.
<pre><code class="hljs">#!/usr/bin/python3

from PyPDF2 import PdfFileReader, PdfFileWriter

pdf_document = &quot;example.pdf&quot;
pdf = PdfFileReader(pdf_document)

# Output files for new PDFs
output_filename_even = &quot;even.pdf&quot;
output_filename_odd = &quot;odd.pdf&quot;

pdf_writer_even = PdfFileWriter()
pdf_writer_odd = PdfFileWriter()

# Get reach page and add it to corresponding
# output file based on page number
for page in range(pdf.getNumPages()):
 current_page = pdf.getPage(page)
 if page % 2 == 0:
 pdf_writer_odd.addPage(current_page)
 else:
 pdf_writer_even.addPage(current_page)

# Write the data to disk
with open(output_filename_even, &quot;wb&quot;) as out:
 pdf_writer_even.write(out)
 print(&quot;created&quot;, output_filename_even)

# Write the data to disk
with open(output_filename_odd, &quot;wb&quot;) as out:
 pdf_writer_odd.write(out)
 print(&quot;created&quot;, output_filename_odd)
</code></pre>
<h2 id="conclusion">Conclusion</h2>
Re-writing and re-arranging the structure of a PDF is fairly easy with the libraries<code> pdfrw</code>, <code>PyMuPDF</code>, and <code>PyPDF2</code>. With just a few lines of Python code you can delete pages, separate them, and add new content.

Frank Hofmann

Working with PDFs in Python: Inserting, Deleting, and Reordering Pages