Adam McQuistan

Asynchronous Tasks in Django with Redis and Celery

<h2 id="introduction">Introduction</h2>
Hypertext Transfer Protocol (HTTP) is an application-layer protocol, which without exaggeration, is pretty much the backbone of Internet browsing as we know it.
It's used for transferring hypermedia documents between the client and the server and is an essential part of every single web application, including any APIs that use the REST architecture.
It allows the browser to communicate with the server by sending requests for certain documents, be it HTML documents (returned as the pages we see) or the hypermedia (pictures, videos, etc) that are served on the pages.
<h2 id="howdoeshttpwork">How Does HTTP Work?</h2>
When we decide to visit a website, what happens behind the curtains is that our computer generates and sends a request to the server on which the website is hosted.
An HTTP request could look something like this:
<pre><code class="hljs">GET /tag/java/ HTTP/1.1
Host: stackabuse.com
Accept: */*
User-Agent: Mozilla/5.0 (platform; rv:geckoversion) Gecko/geckotrail Firefox/firefoxversion
</code></pre>
Here, we request that the server sends back the page under the URL <code>stackabuse.com/tag/java/</code> using HTTP version 1.1.
What the server should respond is something like this:
<pre><code class="hljs">HTTP/1.1 200 OK
Date: Fri, 01 Feb 2019 22:07:06 GMT
Content-Type: text/html; charset=utf-8
Transfer-Encoding: chunked
Connection: keep-alive
Set-Cookie: __cfduid=dd40ff971a6cefddc4855e028541f79581549051234; expires=Sat, 01-Feb-20 22:07:06 GMT; path=/; domain=.stackabuse.com; HttpOnly; Secure
...
</code></pre>
Followed by the response body:
<pre><code class="hljs">&lt;!DOCTYPE html&gt;
&lt;html lang=&quot;en&quot;&gt;
&lt;head&gt;
 &lt;meta charset=&quot;utf-8&quot; /&gt;
 &lt;meta http-equiv=&quot;X-UA-Compatible&quot; content=&quot;IE=edge&quot; /&gt;
 &lt;title&gt;java - Page 1 - Stack Abuse&lt;/title&gt;
 &lt;meta name=&quot;description&quot; content=&quot;&quot; /&gt;
 &lt;meta name=&quot;keywords&quot; content=&quot;&quot;&gt;

&lt;!-- rest of the page --&gt;
</code></pre>
The response body will then be rendered in our browser and we're greeted with a page!
<img src="https://s3.amazonaws.com/stackabuse/media/how-to-send-http-requests-in-java-1.JPG" alt="stackabuse_java">
Besides the <code>HTTP/1.1 200 OK</code> status code that we've received as a response, there are several others that you have likely encountered in your daily lives:
<ul>
<li>1xx: Any status starting with '1' is an informational status. The request is received and is being processed.</li>
<li>2xx: Any status starting with '2' means that the request was successful. Most of the time it's <code>200 OK</code> which simply means that everything went smoothly.</li>
<li>3xx: Any status starting with '3' means that the user needs to be redirected to finish the action.</li>
<li>4xx: Any status starting with '4' indicates a client error. The most notorious one is <code>404 Not Found</code>, usually due to a bad request or syntax. Alongside it, there are <code>400 Bad Request</code>, <code>401 Unauthorized</code> and <code>403 Forbidden</code>. These status codes are the most common and there's a wide range of them.</li>
<li>5xx: Any status starting with '5' indicates a server error.</li>
</ul>
The <a rel="nofollow" target="_blank" href="https://en.wikipedia.org/wiki/List_of_HTTP_status_codes">full list of HTTP status codes</a> is quite long, though it's not a bad idea to go through it.
<h2 id="sendingrequestswithhttpurlconnection">Sending Requests with HttpURLConnection</h2>
<a rel="nofollow" target="_blank" href="https://docs.oracle.com/javase/8/docs/api/java/net/HttpURLConnection.html">HttpURLConnection</a> is the Java core class for handling HTTP requests and responses.
Using <code>HttpURLConnection</code> is perfectly fine for simple HTTP requests, though if you'd like to more easily add things like headers or authentication, you'll have an easier time relying on other libraries such as Apache Commons.
The simplest way to instantiate the <code>HttpURLConnection</code> object is using the <code>URL</code> object:
<pre><code class="hljs">URL url = new URL(&quot;https://www.stackabuse.com&quot;);
HttpURLConnection connection = (HttpURLConnection) url.openConnection();
</code></pre>
<h3 id="requesttypes">Request Types</h3>
Now that our <code>HttpURLConnection</code> instance exists, we can define an HTTP request type for it:
<pre><code class="hljs">// For a GET request
connection.setRequestMethod(&quot;GET&quot;);

// For a POST request
connection.setRequestMethod(&quot;POST&quot;);

// For a HEAD request
connection.setRequestMethod(&quot;HEAD&quot;);

// For a OPTIONS request
connection.setRequestMethod(&quot;OPTIONS&quot;);

// For a PUT request
connection.setRequestMethod(&quot;PUT&quot;);

// For a DELETE request
connection.setRequestMethod(&quot;DELETE&quot;);

// For a TRACE request
connection.setRequestMethod(&quot;TRACE&quot;);
</code></pre>
Though, in most cases you'll only use GET, POST, and DELETE.
<h3 id="requestparameters">Request Parameters</h3>
In some cases, we'd want to send an HTTP request with certain query parameters, such as <code>www.youtube.com/watch?v=dQw4w9WgXcQ</code>.
To achieve this, we'd usually come up with a way to pair these values. Sometimes, people define their own classes to hold these values, though a simple <code>HashMap</code> will do just fine:
<pre><code class="hljs">Map&lt;String, String&gt; params = new HashMap&lt;&gt;();
params.put(&quot;v&quot;, &quot;dQw4w9WgXcQ&quot;);
</code></pre>
Now that we have our parameter(s) mapped, we need to do a couple of things to get them prepared for our request:
<ul>
<li>Generate the parameter in a String-like format. We'll be using <code>StringBuilder</code> as it's ideal for concatenation that we'll perform</li>
<li>Use the <a rel="nofollow" target="_blank" href="https://docs.oracle.com/javase/8/docs/api/index.html?java/net/URLEncoder.html">URLEncoder</a> class to encode our parameters</li>
<li>Convert the data into bytes, as our <code>DataOutputStream</code> that fires the request expects an array of type <code>byte</code></li>
</ul>
Note: If you're unsure why we need to encode our URL - it's because certain characters can have special meaning within URLs. Characters such as &quot;/&quot;, &quot;.&quot;, &quot;#&quot;, and &quot;?&quot; can alter the request, so if they're present we need to encode them in a way that won't affect how the URL is interpreted.
Let's implement the items from the list:
<pre><code class="hljs">// Instantiate a requestData object to store our data
StringBuilder requestData = new StringBuilder();

for (Map.Entry&lt;String, String&gt; param : params.entrySet()) {
 if (requestData.length() != 0) {
 requestData.append(&#x27;&amp;&#x27;);
 }
 // Encode the parameter based on the parameter map we&#x27;ve defined
 // and append the values from the map to form a single parameter
 requestData.append(URLEncoder.encode(param.getKey(), &quot;UTF-8&quot;));
 requestData.append(&#x27;=&#x27;);
 requestData.append(URLEncoder.encode(String.valueOf(param.getValue()), &quot;UTF-8&quot;));
}

// Convert the requestData into bytes 
byte[] requestDataByes = requestData.toString().getBytes(&quot;UTF-8&quot;);
</code></pre>
And thus, our parameter is ready to be used in the request.
<h3 id="requestheaders">Request Headers</h3>
If you'd like to add a header to a request, it's as easy as:
<pre><code class="hljs">connection.setRequestProperty(&quot;Content-Type&quot;, &quot;application/json&quot;);
connection.setRequestProperty(&quot;Content-Length&quot;, String.valueOf(requestDataBytes.length));
</code></pre>
And if you'd like to read a header from a request:
<pre><code class="hljs">String contentType = connection.getHeaderField(&quot;Content-Type&quot;);
</code></pre>
<h3 id="timeouts">Timeouts</h3>
Another feature <code>HttpURLConnection</code> offers is setting timeouts. We can define timeout intervals for reading or connecting:
<pre><code class="hljs">connection.setConnectTimeout(10000);
connection.setReadTimeout(10000);
</code></pre>
The intervals are, as usual, defined in milliseconds.
So, for example, the connection will timeout if it can't be established within 10 seconds. Similarly, it will also timeout if data can't be read from the connection within 10 seconds.
<h3 id="postrequest">POST Request</h3>
With our request all set up, we can go ahead and fire the POST request:
<pre><code class="hljs">// Set the doOutput flag to true
connection.setDoOutput(true);

// Get the output stream of the connection instance
// and add the parameter to the request
try (DataOutputStream writer = new DataOutputStream(connection.getOutputStream())) {
 writer.write(postDataBytes);
}
</code></pre>
Note: Since we're using a <a target="_blank" href="https://stackabuse.com/the-try-with-resources-statement-in-java/"><code>try-with-resources</code> block</a>, there's no need to flush and close the connection, as it's done automatically at the end of the block.
If you're using a traditional <code>try-catch</code> block, remember to always flush and close the connection:
<pre><code class="hljs">// Always flush and close
writer.flush();
writer.close();
</code></pre>
Here we're sending <code>postDataBytes</code> in our POST request, which is an array of bytes. Check out the demo below for more details on how to generate this.
<h3 id="getrequest">GET Request</h3>
Once we send a POST request, we'd typically want to do something to (or at least view) the response.
GET requests are only meant to retrieve data, so let's go ahead and get a response:
<pre><code class="hljs">// To store our response
StringBuilder content;

// Get the input stream of the connection
try (BufferedReader input = new BufferedReader(new InputStreamReader(connection.getInputStream()))) {
 String line;
 content = new StringBuilder();
 while ((line = input.readLine()) != null) {
 // Append each line of the response and separate them
 content.append(line);
 content.append(System.lineSeparator());
 }
} finally {
 connection.disconnect();
}

// Output the content to the console
System.out.println(content.toString());
</code></pre>
We can extract many different kinds of information from the <code>connection</code> at this point:
<pre><code class="hljs">// Returns the value of the content-type header field
connection.getContentType();

// Returns an unmodifiable Map of the header fields
connection.getHeaderFields();

// Gets the status code from an HTTP response message
connection.getResponseCode();

// Gets the HTTP response message returned along with the response code from a server
connection.getResponseMessage();

// Returns the error stream if the connection failed but the server sent useful data nonetheless
connection.getErrorStream();

// ...etc
</code></pre>
<h2 id="demo">Demo</h2>
Here's how a very simple application would generate a POST request, send it, and then read the response:
<pre><code class="hljs">public static void main(String[] args) throws MalformedURLException, ProtocolException, IOException {
 URL url = new URL(&quot;https://www.youtube.com&quot;);
 HttpURLConnection connection = (HttpURLConnection) url.openConnection();

 connection.setRequestMethod(&quot;POST&quot;);
 Map&lt;String, String&gt; params = new HashMap&lt;&gt;();
 params.put(&quot;v&quot;, &quot;dQw4w9WgXcQ&quot;);

 StringBuilder postData = new StringBuilder();
 for (Map.Entry&lt;String, String&gt; param : params.entrySet()) {
 if (postData.length() != 0) {
 postData.append(&#x27;&amp;&#x27;);
 }
 postData.append(URLEncoder.encode(param.getKey(), &quot;UTF-8&quot;));
 postData.append(&#x27;=&#x27;);
 postData.append(URLEncoder.encode(String.valueOf(param.getValue()), &quot;UTF-8&quot;));
 }

 byte[] postDataBytes = postData.toString().getBytes(&quot;UTF-8&quot;);
 connection.setDoOutput(true);
 try (DataOutputStream writer = new DataOutputStream(connection.getOutputStream())) {
 writer.write(postDataBytes);

 StringBuilder content;

 try (BufferedReader in = new BufferedReader(
 new InputStreamReader(connection.getInputStream()))) {
 String line;
 content = new StringBuilder();
 while ((line = in.readLine()) != null) {
 content.append(line);
 content.append(System.lineSeparator());
 }
 }
 System.out.println(content.toString());
 } finally {
 connection.disconnect();
 }
}
</code></pre>
Running this piece of code surely enough yields the source code of the page we specified to get:
<pre><code class="hljs">&lt;!DOCTYPE html&gt;
&lt;html lang=&quot;sr&quot; data-cast-api-enabled=&quot;true&quot;&gt;
&lt;head&gt;
&lt;!-- rest of the page --&gt; 
</code></pre>
<h2 id="conclusion">Conclusion</h2>
Hypertext Transfer Protocol (HTTP) is an application-layer protocol which, without exaggeration, is a very large and critical component to Internet applications.
<code>HttpURLConnection</code> is the Java core class for handling HTTP requests and responses.
Using <code>HttpURLConnection</code> is perfectly fine for simple HTTP requests, though if you'd like to create more complex HTTP requests with headers or authentication, you'll have a much simpler experience with libraries such as Apache Commons.

David Landup

How to Send HTTP Requests in Java

Olivera Popović

Non-Access Modifiers in Java

<h2 id="introduction">Introduction</h2>
Modifiers are keywords that let us fine-tune access to our class and its members, their scope, and behavior in certain situations. For example, we can control which classes/objects can access certain members of our class, whether a class can be inherited or not, whether we can override a method later, whether we should override a method later, etc.
Modifier keywords are written before the variable/method/class (return) type and name, e.g. <code>private int myVar</code> or <code>public String toString()</code>.
Modifiers in Java fall into one of two groups - access and non-access:
<ul>
<li>Access: <code>public</code>, <code>private</code>, <code>protected</code></li>
<li>Non-access: <code>static</code>, <code>final</code>, <code>abstract</code>, <code>synchronized</code>, <code>volatile</code>, <code>transient</code>, and <code>native</code></li>
</ul>
Want to learn more about non-access modifiers? Check out our article <a target="_blank" href="/non-access-modifiers-in-java/">Non-Access Modifiers in Java</a>.
<h2 id="accessmodifiers">Access Modifiers</h2>
Access modifiers deal with the visibility of class members. They control whether other classes can see or change certain variables/methods of our class.
These types of modifiers are closely related to an important part of Object Oriented Programming called encapsulation. As a reminder, encapsulation is an idea that links data with the code that manipulates it. By controlling access, you can prevent misuse.
For example, by making sure that certain variables can only be accessed through well-defined methods (the typical get/set combination of methods) we make sure that we won't encounter any unexpected values or deny outside access to certain variables/methods altogether.
As previously mentioned, there are three access modifiers: <code>public</code>, <code>private</code>, and <code>protected</code>. Java also provides default access control (when no modifier is specified), which behaves similarly to <code>protected</code>.
<ul>
<li><code>public</code> - the member can be accessed from anywhere</li>
<li><code>protected</code> - the member is only inaccessible from non-subclasses in a different package</li>
<li>default (package-private) - also known as <code>package</code> access, the member can be accessed by any class within the same package</li>
<li><code>private</code> - the member can only be accessed by other members within the same class</li>
</ul>
This table shows all possible access scenarios for class members:
<table class="table table-striped" style="width:100%">
 <tr align="center">
 <th colspan="2"></th>
 <th>Private</th>
 <th>Default</th>
 <th>Protected</th>
 <th>Public</th>
 </tr>
 <tr align="center">
 <td colspan="2" align="left">Same class</td>
 <td>Yes</td>
 <td>Yes</td>
 <td>Yes</td>
 <td>Yes</td>
 </tr>
 <tr align="center">
 <td colspan="2" align="left">Subclass (same package)</td>
 <td>No</td>
 <td>Yes</td>
 <td>Yes</td>
 <td>Yes</td>
 </tr>
 <tr align="center">
 <td colspan="2" align="left">Non-subclass (same package)</td>
 <td>No</td>
 <td>Yes</td>
 <td>Yes</td>
 <td>Yes</td>
 </tr>
 <tr align="center">
 <td colspan="2" align="left">Subclass (different package)</td>
 <td>No</td>
 <td>No</td>
 <td>Yes</td>
 <td>Yes</td>
 </tr>
 <tr align="center">
 <td colspan="2" align="left">Non-subclass (different package)</td>
 <td>No</td>
 <td>No</td>
 <td>No</td>
 <td>Yes</td>
 </tr>
</table>
This table applies only to class members, not classes in general. A non-nested class can only be <code>public</code> or without a modifier. The behavior is logical, when a class is declared without a modifier it can only be accessed by code within the same package, and when it is declared <code>public</code> it can be used in a different package as well.
Note: A <code>public</code> class must be the only (non-nested) class in the file, and the file must have the same name as the class.
For example, let's say we have two packages, creatively named <code>packageOne</code> and <code>packageTwo</code>.
<pre><code class="hljs">package packageOne;

public class MyPublicClass {
 String noModifierText = &quot;No Modifier&quot;;
 private String privateText = &quot;Private Text&quot;;
 protected String protectedText = &quot;Protected Text&quot;;
 public String publicText = &quot;Public Text&quot;;

 public MyPublicClass() {
 // We can access all members of a class from within that class
 System.out.println(&quot;MyPublicClass constructor:&quot;)
 System.out.println(noModifierText);
 System.out.println(privateText);
 System.out.println(protectedText);
 System.out.println(publicText);
 }
}
</code></pre>
Note that the above code is in a file called &quot;MyPublicClass.java&quot;. The name must match the class since we'll make the class public so we can access it from a different package. The same applies to the other classes below.
<pre><code class="hljs">package packageOne;

class SamePackageExtends extends MyPublicClass {
 public SamePackageExtends() {
 System.out.println(&quot;SamePackageExtends constructor:&quot;)
 System.out.println(noModifierText);
 // Trying to access the private member privateText will fail, since private members
 // can only be accessed by members of the same class, even though this class extends it.
 // System.out.println(privateText);
 System.out.println(protectedText);
 System.out.println(publicText);
 }
}
</code></pre>
<pre><code class="hljs">package packageOne;

class SamePackageDoesntExtend {
 // Has the same access as SamePackageExtends
 public SamePackageDoesntExtend() {
 MyPublicClass myPublicClass = new MyPublicClass();

 System.out.println(&quot;SamePackageDoesntExtend constructor:&quot;)
 System.out.println(myPublicClass.noModifierText);
 // System.out.println(myPublicClass.privateText);
 System.out.println(myPublicClass.protectedText);
 System.out.println(myPublicClass.publicText);
 }
}
</code></pre>
<pre><code class="hljs">package packageTwo;

class DifferentPackageExtends extends packageOne.MyPublicClass {
 public DifferentPackageExtends() {
 System.out.println(&quot;DifferentPackageExtends constructor:&quot;)
 // System.out.println(noModifierText); // Same class or same package only
 // System.out.println(privateText); // Same class only
 System.out.println(protectedText);
 System.out.println(publicText);
 }
}
</code></pre>
<pre><code class="hljs">package packageTwo;

class DifferentPackageDoesntExtend {
 public DifferentPackageDoesntExtend() {
 packageOne.MyPublicClass myPublicClass = new packageOne.MyPublicClass();

 System.out.println(&quot;DifferentPackageDoesntExtend constructor:&quot;)
 // System.out.println(myPublicClass.noModifierText);
 // System.out.println(myPublicClass.privateText);
 // System.out.println(myPublicClass.protectedText); // Same package only
 System.out.println(myPublicClass.publicText);
 }
}
</code></pre>
Tip: It's common practice to encapsulate a class. This means that we declare member variables as <code>private</code> and declare <code>public</code> methods that manipulate them. For example, we want to let someone change <code>int ID</code> field but we also want to make sure that <code>int ID</code> is strictly a positive integer. Though the public method, we can first run a check and manipulate the field if the given value passes our check. This is a construct called a <code>set()</code> method, and it's usually accompanied by a <code>get()</code> method (since we can't read private members outside of our class) or when we want to control how and when the value of a variable can be read.
<pre><code class="hljs">class GetSetExample {
 ...
 private int ID = 0; // Default value
 public setID(int n) {
 if (n &gt; 0) {
 ID = n;
 }
 else ID = 0;
 }
 public int getID() {
 // Potential read conditions that need to be met

 return ID;
 }
 ...
}
</code></pre>
One other thing to note is that <code>protected</code> is the least used of all of the access modifiers. It can easily be bypassed if we want to. Even in a different package we can simply inherit the class whose <code>protected</code> members we want to access, and then access them via that inherited class.
With that in mind, <code>protected</code> is most often used as a guideline that says &quot;This member is not meant to be accessed by non-subclasses in a different package&quot;, so even though we can easily bypass <code>protected</code> access control, it's not advisable, since it was most likely put there for a reason.
<h2 id="conclusion">Conclusion</h2>
Modifiers are keywords that let us fine-tune access to our class and its members, their scope and behavior in certain situations. They provide fundamental traits for our classes and their members. Every developer should be thoroughly be acquainted with them to make the best use of them.

Access Modifiers in Java

Guest Contributor

HashMap and TreeMap in Java: Differences and Similarities

In this article, we'll examine how to append content to an existing file using Python.
Let's say we have a file called <code>helloworld.txt</code> containing the text &quot;Hello world!&quot; and it is sitting in our current working directory on a Unix file system:
<pre><code class="hljs">$ cat ./helloworld.txt
Hello world!
</code></pre>
Now assume we want to append the additional text &quot;It's good to have been born!&quot; to the end of this file from a Python program.
The first step is to obtain a reference to the file from our program. This can be done with the built-in <code>open</code> method, using the file path/name as the first argument and the mode as the second argument, as follows:
<pre><code class="hljs">f = open(&quot;./helloworld.txt&quot;, &quot;a&quot;)
</code></pre>
The variable <code>f</code> now holds a reference to a file object that we can use to write to the end of the file. If the file didn't already exist, it will be created. Note that the second argument &quot;a&quot; specified the mode to open the file with, in this case &quot;Append&quot; mode. This sets the writing position to the end of the file.
If we had used the &quot;w&quot; (Write mode), then anything we write to the file will start at the very beginning and overwrite the existing content.
Now we can write content to the file like this:
<pre><code class="hljs">f.write(&quot;\nIt&#x27;s good to have been born!&quot;)

f.close()
</code></pre>
Remember to call the <code>close</code> method after writing to files so that it doesn't remain locked after the program exits and to ensure that any buffered content in memory gets written to the file.
Here is what the file looks like after we append to it:
<pre><code class="hljs">$ cat ./helloworld.txt
Hello world!
It&#x27;s good to have been born!
</code></pre>
One final note is that if we add a &quot;+&quot; to the mode argument of the <code>open</code> method, we can open the file for both appending and reading. This will enable both reading and writing to the file. Without the &quot;+&quot; an <code>IOError</code> exception will occur if we try to read from the file. By default both reading and writing will occur at the end of the file, but this can be changed at any time using the <code>seek</code> method.
Here are the commands to achieve this (note that we use the <code>flush</code> method to ensure the new content is written to the file before we try to read it back):
<pre><code class="hljs">f = open(&quot;./helloworld.txt&quot;, &quot;a+&quot;)
f.write(&quot;I am grateful.&quot;)
f.flush() 
f.seek(0)
content = f.read()
print content
f.close()
</code></pre>
And here is what the final file looks like:
<pre><code class="hljs">$ cat ./helloworld.txt
Hello world!
It&#x27;s good to have been born!
I am grateful.
</code></pre>
<h2 id="abouttheauthor">About the Author</h2>
This article was written by Jacob Stopak, a software consultant and developer with passion for helping others improve their lives through code. Jacob is the creator of <a rel="nofollow" target="_blank" href="https://initialcommit.com">Initial Commit</a> - a site dedicated to helping curious developers learn how their favorite programs are coded. Its featured project helps people <a rel="nofollow" target="_blank" href="https://initialcommit.com/blog/Learn-Git-Code-Definitive-Guide">learn Git</a> at the code level.
In this article, we'll examine how to append content to an existing file using Python.
Let's say we have a file called <code>helloworld.txt</code> containing the text &quot;Hello world!&quot; and it is sitting in our current working directory on a Unix file system:
<pre><code class="hljs">$ cat ./helloworld.txt
Hello world!
</code></pre>
Now assume we want to append the additional text &quot;It's good to have been born!&quot; to the end of this file from a Python program.
The first step is to obtain a reference to the file from our program. This can be done with the built-in <code>open</code> method, using the file path/name as the first argument and the mode as the second argument, as follows:
<pre><code class="hljs">f = open(&quot;./helloworld.txt&quot;, &quot;a&quot;)
</code></pre>
The variable <code>f</code> now holds a reference to a file object that we can use to write to the end of the file. If the file didn't already exist, it will be created. Note that the second argument &quot;a&quot; specified the mode to open the file with, in this case &quot;Append&quot; mode. This sets the writing position to the end of the file.
If we had used the &quot;w&quot; (Write mode), then anything we write to the file will start at the very beginning and overwrite the existing content.
Now we can write content to the file like this:
<pre><code class="hljs">f.write(&quot;\nIt&#x27;s good to have been born!&quot;)

f.close()
</code></pre>
Remember to call the <code>close</code> method after writing to files so that it doesn't remain locked after the program exits and to ensure that any buffered content in memory gets written to the file.
Here is what the file looks like after we append to it:
<pre><code class="hljs">$ cat ./helloworld.txt
Hello world!
It&#x27;s good to have been born!
</code></pre>
One final note is that if we add a &quot;+&quot; to the mode argument of the <code>open</code> method, we can open the file for both appending and reading. This will enable both reading and writing to the file. Without the &quot;+&quot; an <code>IOError</code> exception will occur if we try to read from the file. By default both reading and writing will occur at the end of the file, but this can be changed at any time using the <code>seek</code> method.
Here are the commands to achieve this (note that we use the <code>flush</code> method to ensure the new content is written to the file before we try to read it back):
<pre><code class="hljs">f = open(&quot;./helloworld.txt&quot;, &quot;a+&quot;)
f.write(&quot;I am grateful.&quot;)
f.flush() 
f.seek(0)
content = f.read()
print content
f.close()
</code></pre>
And here is what the final file looks like:
<pre><code class="hljs">$ cat ./helloworld.txt
Hello world!
It&#x27;s good to have been born!
I am grateful.
</code></pre>
<h2 id="abouttheauthor">About the Author</h2>
This article was written by Jacob Stopak, a software consultant and developer with passion for helping others improve their lives through code. Jacob is the creator of <a rel="nofollow" target="_blank" href="https://initialcommit.com">Initial Commit</a> - a site dedicated to helping curious developers learn how their favorite programs are coded. Its featured project helps people <a rel="nofollow" target="_blank" href="https://initialcommit.com/blog/Learn-Git-Code-Definitive-Guide">learn Git</a> at the code level.

Jacob Stopak

Python: Append Contents to a File

Overview of Async IO in Python 3.7

<h2 id="introduction">Introduction</h2>
In this tutorial, we're going to learn how to use <a rel="nofollow" target="_blank" href="http://pyopengl.sourceforge.net">PyOpenGL</a> library in Python. OpenGL is a graphics library which is supported by multiple platforms including Windows, Linux, and MacOS, and is available for use in multiple other languages as well; however, the scope of this post will be limited to its usage in the Python programming language.
OpenGL, as compared to other similar graphics libraries, is fairly simple. We'll start with setting it up on our system, followed by writing a simple example demonstrating the usage of the library.
<h2 id="installation">Installation</h2>
The easiest way to install OpenGL using Python is through the <a rel="nofollow" target="_blank" href="https://pypi.org/project/pip/">pip</a> package manager. If you have pip installed in your system, run the following command to download and install OpenGL:
<pre><code class="hljs">$ pip install PyOpenGL PyOpenGL_accelerate
</code></pre>
I'd recommend copying the above command to help avoid typos.
Once this command finishes execution, if the installation is successful, you should get the following output at the end:
<pre><code class="hljs">Successfully installed PyOpenGL-3.1.0 PyOpenGL-accelerate-3.1.0
</code></pre>
If this doesn't work, you can also download it manually. For that, <a rel="nofollow" target="_blank" href="http://pyopengl.sourceforge.net">this link</a>, scroll down to the 'downloading and installation' heading, and download all the files over there. After that, navigate to the folder where you downloaded those files, and run the following command in the terminal or command prompt:
<pre><code class="hljs">$ python setup.py
</code></pre>
It is pertinent to mention that you require Visual C++ 14.0 build tools installed on your system in order to work with OpenGL libraries in Python.
Now that we have successfully installed OpenGL on our system, let's get our hands dirty with it.
<h2 id="codingexercise">Coding Exercise</h2>
The first thing we need to do to use OpenGL in our code is to import it. To do that, run the following command:
<pre><code class="hljs">import OpenGL
</code></pre>
Before we proceed, there are a few other libraries that you need to import whenever you intend to use this library in your program. Below is the code for those imports:
<pre><code class="hljs">import OpenGL.GL
import OpenGL.GLUT
import OpenGL.GLU
print(&quot;Imports successful!&quot;) # If you see this printed to the console then installation was successful
</code></pre>
Now that we are done with the necessary imports, let's first create a window in which our graphics will be shown. The code for that is given below, along with its explanation in the comments:
<pre><code class="hljs">def showScreen():
 glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT) # Remove everything from screen (i.e. displays all white)

glutInit() # Initialize a glut instance which will allow us to customize our window
glutInitDisplayMode(GLUT_RGBA) # Set the display mode to be colored
glutInitWindowSize(500, 500) # Set the width and height of your window
glutInitWindowPosition(0, 0) # Set the position at which this windows should appear
wind = glutCreateWindow(&quot;OpenGL Coding Practice&quot;) # Give your window a title
glutDisplayFunc(showScreen) # Tell OpenGL to call the showScreen method continuously
glutIdleFunc(showScreen) # Draw any graphics or shapes in the showScreen function at all times
glutMainLoop() # Keeps the window created above displaying/running in a loop
</code></pre>
Copy the imports above, as well as this code in a single python (.py) file, and execute it. You should see a white square dimension screen pop up. Now, if we wish to draw any shapes or make any other kind of graphics, we need to do that in our &quot;showScreen&quot; function.
Let's now try to make a square using OpenGL, but before we do we need to understand the coordinate system that OpenGL follows.
The (0,0) point is the bottom left of your window, if you go up from there, you're moving along the y-axis, and if you go right from there, you're moving along the x-axis. So, the top left point of your window would be (0, 500), top right would be (500, 500), bottom right would be (500, 0).
Note: We're talking about the window we created above, which had a dimension of 500 x 500 in our example, and not your computer's full screen.
Now that we've got that out of the way, let's code a square. The explanation to the code can be found in the comments.
<pre><code class="hljs">from OpenGL.GL import *
from OpenGL.GLUT import *
from OpenGL.GLU import *

w, h = 500,500

# ---Section 1---
def square():
 # We have to declare the points in this sequence: bottom left, bottom right, top right, top left
 glBegin(GL_QUADS) # Begin the sketch
 glVertex2f(100, 100) # Coordinates for the bottom left point
 glVertex2f(200, 100) # Coordinates for the bottom right point
 glVertex2f(200, 200) # Coordinates for the top right point
 glVertex2f(100, 200) # Coordinates for the top left point
 glEnd() # Mark the end of drawing

# This alone isn&#x27;t enough to draw our square

# ---Section 2---

def showScreen():
 glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT) # Remove everything from screen (i.e. displays all white)
 glLoadIdentity() # Reset all graphic/shape&#x27;s position
 square() # Draw a square using our function
 glutSwapBuffers()

#---Section 3---

glutInit()
glutInitDisplayMode(GLUT_RGBA) # Set the display mode to be colored
glutInitWindowSize(500, 500) # Set the w and h of your window
glutInitWindowPosition(0, 0) # Set the position at which this windows should appear
wind = glutCreateWindow(&quot;OpenGL Coding Practice&quot;) # Set a window title
glutDisplayFunc(showScreen)
glutIdleFunc(showScreen) # Keeps the window open
glutMainLoop() # Keeps the above created window displaying/running in a loop
</code></pre>
Running the code above would draw a square, but that square would not be visible since it's color would be the same as the color of our window, so we need to assign it a different color as well, for that we will make some changes in &quot;Section 2&quot; of the code above i.e. the <code>showScreen</code> function. Add the following line below the <code>glLoadIdentity</code> statement and above the <code>square()</code> statement:
<pre><code class="hljs">glColor3f(1.0, 0.0, 3.0) # Set the color to pink
</code></pre>
However, our code is still not complete. What it currently does is draw the square once, and then clear the screen again. We don't want that. Actually, we won't even be able to spot the moment when it actually draws the square because it would appear and disappear in a split second. Let's write another function to avoid this.
<pre><code class="hljs"># Add this function before Section 2 of the code above i.e. the showScreen function
def iterate():
 glViewport(0, 0, 500,500)
 glMatrixMode(GL_PROJECTION)
 glLoadIdentity()
 glOrtho(0.0, 500, 0.0, 500, 0.0, 1.0)
 glMatrixMode (GL_MODELVIEW)
 glLoadIdentity()
</code></pre>
Call this iterate function in &quot;Section 2&quot; of the code above. Add it below <code>glLoadIdentity</code> and above the <code>glColor3d</code> statement in the <code>showScreen</code> function.
Let's now compile all this into a single code file so that there are no ambiguities:
<pre><code class="hljs">from OpenGL.GL import *
from OpenGL.GLUT import *
from OpenGL.GLU import *

w,h= 500,500
def square():
 glBegin(GL_QUADS)
 glVertex2f(100, 100)
 glVertex2f(200, 100)
 glVertex2f(200, 200)
 glVertex2f(100, 200)
 glEnd()

def iterate():
 glViewport(0, 0, 500, 500)
 glMatrixMode(GL_PROJECTION)
 glLoadIdentity()
 glOrtho(0.0, 500, 0.0, 500, 0.0, 1.0)
 glMatrixMode (GL_MODELVIEW)
 glLoadIdentity()

def showScreen():
 glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT)
 glLoadIdentity()
 iterate()
 glColor3f(1.0, 0.0, 3.0)
 square()
 glutSwapBuffers()

glutInit()
glutInitDisplayMode(GLUT_RGBA)
glutInitWindowSize(500, 500)
glutInitWindowPosition(0, 0)
wind = glutCreateWindow(&quot;OpenGL Coding Practice&quot;)
glutDisplayFunc(showScreen)
glutIdleFunc(showScreen)
glutMainLoop()
</code></pre>
When you run this, a window should appear with a pink colored square box in it.
Output:
<img class="img-responsive" src="https://s3.amazonaws.com/stackabuse/media/brief-introduction-opengl-python-pyopengl-1.png">
<h2 id="conclusion">Conclusion</h2>
In this tutorial, we learned about OpenGL, how to download and install it, followed by using it as a short example program. In this example we also practiced making a basic shape using OpenGL, which gave us an insight into some complex function calls that need to be made whenever we need to draw something using this library. To conclude, OpenGL is very resourceful and gets more and more complex as we dive deeper into it.

Muhammad Junaid Khalid

Brief Introduction to OpenGL in Python with PyOpenGL

Usman Malik

Python for NLP: Working with the Gensim Library (Part 2)