<h2 id="introduction">Introduction</h2>
<p>Python, like any other programming language, has its own set of rules and conventions when it comes to naming variables and functions. These conventions aren't just for aesthetics or to make your code look pretty, they serve a much more important role in making your code more readable and maintainable. If you've read many of my articles on StackAbuse, I talk a lot about writing readable code. By following Pythonic best-practices in naming and formatting your code, you'll make it much more readable for others (and yourself).</p>
<p>In this article, we'll explore the different naming conventions used in Python and understand why they matter.</p>
<h2 id="whynamingconventionsmatter">Why Naming Conventions Matter</h2>
<p>Imagine working on a large codebase where variables and functions are named/formatted haphazardly. It would be a nightmare to understand what each variable or function does, let alone debug or add new features. This is one of the reasons why we put so much emphasis on following conventions.</p>
<p>Naming conventions are basically just agreed-upon standards that programmers follow when naming their variables, functions, classes, and other code elements. They provide a level of predictability that makes it easier to understand the purpose of a piece of code. This is especially important when you're working in a team.</p>
<p>Following naming conventions isn't just about making your code understandable to others. It's also about making it easier for your future self. You might understand your code perfectly well now, but you might not remember what everything does six months down the line.</p>
<h2 id="variablenamingconventions">Variable Naming Conventions</h2>
<p>In Python, variable names are more than just placeholders for values - they are a vital part of your code's readability. Python's variable naming convention is based on the principle of &quot;readability counts&quot;, one of the <a rel="nofollow noopener" target="_blank" href="https://en.wikipedia.org/wiki/Zen_of_Python">guiding philosophies of Python</a>.</p>
<p>A variable name in Python should be descriptive and concise, making it easy for anyone reading your code to understand what the variable is used for. It should start with a lowercase letter, and it can include letters, numbers, and underscores. However, it cannot start with a number.</p>
<p>Here are some examples:</p>
<pre><code class="hljs">name = <span class="hljs-string">&quot;John Doe&quot;</span>
age = <span class="hljs-number">30</span>
is_student = <span class="hljs-literal">False</span>
</code></pre>

            <div class="alert alert-note">
                <div class="flex">
                    
                        <div class="flex-shrink-0 mr-3">
                            <img src="/assets/images/icon-information-circle-solid.svg" class="icon" aria-hidden="true" />
                        </div>
                        
                    <div class="w-full">
            <p><strong>Note:</strong> Python is case sensitive, which means <code>age</code>, <code>Age</code>, and <code>AGE</code> are three different variables.</p>

                    </div>
                </div>
            </div>
            <p>In Python, we commonly use <code>snake_case</code> for variable names, where each word is separated by an underscore. This is also known as <code>lower_case_with_underscores</code>.</p>
<pre><code class="hljs">student_name = <span class="hljs-string">&quot;John Doe&quot;</span>
student_age = <span class="hljs-number">30</span>
is_student = <span class="hljs-literal">False</span>
</code></pre>
<h2 id="functionnamingconventions">Function Naming Conventions</h2>
<p>Like variable names, function names in Python should be descriptive and concise. The function name should clearly indicate what the function does. Python's naming conventions for functions are similar to its conventions for variables.</p>
<p>In Python, we typically use <code>snake_case</code> for function names. Here's an example:</p>
<pre><code class="hljs"><span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">calculate_sum</span>(<span class="hljs-params">a, b</span>):</span>
    <span class="hljs-keyword">return</span> a + b

result = calculate_sum(<span class="hljs-number">5</span>, <span class="hljs-number">3</span>)
<span class="hljs-built_in">print</span>(result)  <span class="hljs-comment"># Output: 8</span>
</code></pre>

            <div class="alert alert-note">
                <div class="flex">
                    
                        <div class="flex-shrink-0 mr-3">
                            <img src="/assets/images/icon-information-circle-solid.svg" class="icon" aria-hidden="true" />
                        </div>
                        
                    <div class="w-full">
            <p><strong>Note:</strong> It's a good practice to use verbs in function names since a function typically performs an action.</p>

                    </div>
                </div>
            </div>
            <p>In addition to <code>snake_case</code>, Python also uses <code>PascalCase</code> for naming classes, and occassionally <code>camelCase</code>, but we'll focus on those in another section. For now, remember that consistency in your naming convention is important for to writing clean, Pythonic code.</p>
<h2 id="classnamingconventions">Class Naming Conventions</h2>
<p>For naming classes in Python, a different set of conventions applies compared to naming variables or functions. In Python, class names typically use <code>PascalCase</code>, also known as <code>UpperCamelCase</code>. This means that the name starts with an uppercase letter and has no underscores between words. Each word in the name should also start with an uppercase letter.</p>
<p>Here's an example to illustrate the naming convention for classes:</p>
<pre><code class="hljs"><span class="hljs-class"><span class="hljs-keyword">class</span> <span class="hljs-title">ShoppingCart</span>:</span>
    <span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">__init__</span>(<span class="hljs-params">self, items=[]</span>):</span>
        self.items = items
    
    <span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">add_item</span>(<span class="hljs-params">self, item</span>):</span>
        self.items.append(item)

my_cart = ShoppingCart()
my_cart.add_item(<span class="hljs-string">&quot;apple&quot;</span>)
</code></pre>
<p>In this example, <code>ShoppingCart</code> is a class that adheres to the <code>PascalCase</code> naming convention.</p>

            <div class="alert alert-note">
                <div class="flex">
                    
                        <div class="flex-shrink-0 mr-3">
                            <img src="/assets/images/icon-information-circle-solid.svg" class="icon" aria-hidden="true" />
                        </div>
                        
                    <div class="w-full">
            <p><strong>Note:</strong> While function names often use verbs to indicate actions, class names usually employ nouns or noun phrases. This is because a class often represents a thing or a concept rather than an action.</p>

                    </div>
                </div>
            </div>
            <p>Sometimes you'll encounter classes that contain acronyms or initialisms. In such cases, it's conventional to keep the entire acronym uppercase:</p>
<pre><code class="hljs"><span class="hljs-class"><span class="hljs-keyword">class</span> <span class="hljs-title">HTTPResponse</span>:</span>
    <span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">__init__</span>(<span class="hljs-params">self, status_code, content</span>):</span>
        self.status_code = status_code
        self.content = content
</code></pre>
<p>Just like with functions, the key to good class naming is to be descriptive and concise. The name should clearly convey the class's purpose or functionality. And as always, maintaining consistency in your naming conventions throughout your codebase is vital for readability and maintainability.</p>
<h2 id="conclusion">Conclusion</h2>
<p>In this article, we've explored the importance of naming conventions in Python, and how they contribute to code readability and maintainability. We've showed the different types of naming conventions for variables, functions, and classes, like <code>PascalCasing</code> and <code>snake_casing</code>.</p>
<p>Python does not enforce these conventions, but adhering to them is considered good practice and can really improve your code's readability, especially when working in teams.</p>


Scott Robinson

Python Naming Conventions for Variables, Functions, and Classes

<h2 id="introduction">Introduction</h2>
<p>As JavaScript developers, we often need to handle large chunks of text data, which may span across multiple lines. This is where multiline strings come into play. They allow you to maintain the formatting and readability of your code without compromising the string's structure.</p>
<p>In this article, we are going to explore various ways to create multiline strings in JavaScript.</p>
<h2 id="whyusemultilinestrings">Why Use Multiline Strings?</h2>
<p>When dealing with large text data or template literals, it's not uncommon to have strings that span multiple lines. In traditional JavaScript, you would have to use the <code>\n</code> character to create a new line, which can make your code hard to read and maintain.</p>
<p>For instance, let's say you want to create a string for an email template:</p>
<pre><code class="hljs"><span class="hljs-keyword">var</span> emailTemplate = <span class="hljs-string">&quot;Dear User,\n\nThank you for signing up for our service.\n\nBest,\nTeam&quot;</span>
</code></pre>
<p>The <code>\n</code> character creates a new line, but it makes the code look cluttered. Multiline strings can solve this problem by allowing you to create strings that span multiple lines in a more readable and maintainable way.</p>

            <div class="alert alert-note">
                <div class="flex">
                    
                        <div class="flex-shrink-0 mr-3">
                            <img src="/assets/images/icon-information-circle-solid.svg" class="icon" aria-hidden="true" />
                        </div>
                        
                    <div class="w-full">
            <p><strong>Note:</strong> Multiline strings are not just about aesthetics or readability. They also play an important role in template literals and regular expressions, which we will see later in this article.</p>

                    </div>
                </div>
            </div>
            <h2 id="multilinestringsthetraditionalway">Multiline Strings: The Traditional Way</h2>
<p>In the early days of JavaScript, creating multiline strings was a bit cumbersome. If you wanted to create a string that spanned more than one line, you had to use the newline character (<code>\n</code>) to break the line, or concatenate multiple strings using the <code>+</code> operator.</p>
<p>Here's an example:</p>
<pre><code class="hljs"><span class="hljs-keyword">var</span> multilineString = <span class="hljs-string">&#x27;This is line 1\n&#x27;</span> +
                      <span class="hljs-string">&#x27;This is line 2\n&#x27;</span> +
                      <span class="hljs-string">&#x27;This is line 3&#x27;</span>;
<span class="hljs-built_in">console</span>.log(multilineString);
</code></pre>
<p>The output would be:</p>
<pre><code class="hljs">This is line 1
This is line 2
This is line 3
</code></pre>
<p>As you can see, this method can get quite messy and hard to read when dealing with larger strings.</p>

            <div class="alert alert-note">
                <div class="flex">
                    
                        <div class="flex-shrink-0 mr-3">
                            <img src="/assets/images/icon-information-circle-solid.svg" class="icon" aria-hidden="true" />
                        </div>
                        
                    <div class="w-full">
            <p><strong>Note:</strong> The <code>\n</code> character is a special character that represents a newline. When used in a string, it causes the string to break and start a new line.</p>

                    </div>
                </div>
            </div>
            <h2 id="multilinestringsthees6way">Multiline Strings: The ES6 Way</h2>
<p>With the introduction of ES6 (ES2015), JavaScript got a new feature called template literals. Template literals are a new kind of string literals that are enclosed by backticks (<code>``</code>) instead of single or double quotes.</p>
<p>One of the advantages of template literals is that they can span multiple lines without needing any special characters or concatenation. This makes them a perfect choice for creating multiline strings.</p>
<p>Here's how you can create a multiline string using template literals:</p>
<pre><code class="hljs"><span class="hljs-keyword">let</span> multilineString = <span class="hljs-string">`This is line 1
This is line 2
This is line 3`</span>;
<span class="hljs-built_in">console</span>.log(multilineString);
</code></pre>
<p>The output would be:</p>
<pre><code class="hljs">This is line 1
This is line 2
This is line 3
</code></pre>
<p>As you can see, the syntax is much cleaner and easier to read.</p>

            <div class="alert alert-note">
                <div class="flex">
                    
                        <div class="flex-shrink-0 mr-3">
                            <img src="/assets/images/icon-information-circle-solid.svg" class="icon" aria-hidden="true" />
                        </div>
                        
                    <div class="w-full">
            <p><strong>Note:</strong> In addition to multiline strings, template literals also support string interpolation, which allows you to embed expressions within the string that will be evaluated and inserted into the string. This can be very useful when you need to include variables or expressions in your string.</p>

                    </div>
                </div>
            </div>
            <h2 id="heredocinjavascript">Heredoc in JavaScript</h2>
<p>&quot;Heredoc&quot; is a term borrowed from the Perl programming language. It stands for &quot;Here Document&quot; and is used to create multiline strings in a more readable and manageable way. Unfortunately, JavaScript doesn’t natively support heredoc, but we can emulate it using template literals introduced in ES6.</p>
<p>A heredoc-like multiline string in JavaScript would look like this:</p>
<pre><code class="hljs"><span class="hljs-keyword">let</span> str = <span class="hljs-string">`
This is a multiline string
which spans multiple lines.
`</span>;

<span class="hljs-built_in">console</span>.log(str);
</code></pre>
<p>Output:</p>
<pre><code class="hljs">This is a multiline string
which spans multiple lines.
</code></pre>
<p>The backtick (<code>`</code>) character, which is usually located below the escape key on a keyboard, is used to define a template literal in JavaScript. Everything within the backticks is part of the string, including new lines or other special characters.</p>

            <div class="alert alert-note">
                <div class="flex">
                    
                        <div class="flex-shrink-0 mr-3">
                            <img src="/assets/images/icon-information-circle-solid.svg" class="icon" aria-hidden="true" />
                        </div>
                        
                    <div class="w-full">
            <p><strong>Note:</strong> The backtick (<code>`</code>) is not the same as a single quote (<code>'</code>) or a double quote (<code>&quot;</code>). Make sure you're using the correct character when defining template literals.</p>

                    </div>
                </div>
            </div>
            <h2 id="variationsofmultilinestrings">Variations of Multiline Strings</h2>
<p>In addition to the standard way of creating multiline strings in JavaScript, there are several variations that can be used depending on your specific needs.</p>
<h3 id="concatenation">Concatenation</h3>
<p>Before ES6, developers often used concatenation to create multiline strings. This method involves breaking the string into multiple parts and using the plus (+) operator to join them together.</p>
<pre><code class="hljs"><span class="hljs-keyword">let</span> str = <span class="hljs-string">&quot;This is a multiline string &quot;</span> +
<span class="hljs-string">&quot;which spans multiple lines.&quot;</span>;

<span class="hljs-built_in">console</span>.log(str);
</code></pre>
<p>Output:</p>
<pre><code class="hljs">This is a multiline string which spans multiple lines.
</code></pre>
<h3 id="arrayjoin">Array Join</h3>
<p>Another variation is to use the <code>join()</code> method of an array to create a multiline string. Each element of the array becomes a line in the string.</p>
<pre><code class="hljs"><span class="hljs-keyword">let</span> str = [<span class="hljs-string">&quot;This is a multiline string&quot;</span>, <span class="hljs-string">&quot;which spans multiple lines.&quot;</span>].join(<span class="hljs-string">&quot;\n&quot;</span>);

<span class="hljs-built_in">console</span>.log(str);
</code></pre>
<p>Output:</p>
<pre><code class="hljs">This is a multiline string
which spans multiple lines.
</code></pre>
<h3 id="templateliteralswithvariables">Template Literals with Variables</h3>
<p>Template literals in ES6 also allow for variable interpolation. This means you can include variables within your multiline string, and their values will be included in the final string.</p>
<pre><code class="hljs"><span class="hljs-keyword">let</span> line1 = <span class="hljs-string">&quot;This is a multiline string&quot;</span>;
<span class="hljs-keyword">let</span> line2 = <span class="hljs-string">&quot;which spans multiple lines.&quot;</span>;

<span class="hljs-keyword">let</span> str = <span class="hljs-string">`<span class="hljs-subst">${line1}</span>
<span class="hljs-subst">${line2}</span>`</span>;

<span class="hljs-built_in">console</span>.log(str);
</code></pre>
<p>Output:</p>
<pre><code class="hljs">This is a multiline string
which spans multiple lines.
</code></pre>
<p>These variations provide flexibility when working with multiline strings in JavaScript, allowing you to choose the method that best suits your needs.</p>
<h2 id="usecasemultilinestringsintemplateliterals">Use Case: Multiline Strings in Template Literals</h2>
<p>Template literals, introduced in ES6, are a new way to handle strings in JavaScript. They are enclosed by the backtick (<code>`</code>) character instead of double or single quotes. One of the main benefits of template literals is their ability to handle multiline strings effortlessly.</p>
<p>Let's see how we can use multiline strings within template literals.</p>
<pre><code class="hljs"><span class="hljs-keyword">let</span> multilineString = <span class="hljs-string">`This is line one
and this is line two
and this is line three`</span>;

<span class="hljs-built_in">console</span>.log(multilineString);
</code></pre>
<p>The output of the above code will be:</p>
<pre><code class="hljs">This is line one
and this is line two
and this is line three
</code></pre>
<p>As you can see, template literals maintain the line breaks and spacing of the text within them, which makes them an excellent choice for working with multiline strings in JavaScript.</p>

            <div class="alert alert-note">
                <div class="flex">
                    
                        <div class="flex-shrink-0 mr-3">
                            <img src="/assets/images/icon-information-circle-solid.svg" class="icon" aria-hidden="true" />
                        </div>
                        
                    <div class="w-full">
            <p><strong>Note:</strong> Template literals also support string interpolation, which allows you to embed expressions (variables, functions, etc.) within the string. This is another reason why they are often preferred for handling complex strings.</p>

                    </div>
                </div>
            </div>
            <h2 id="usecasemultilinestringsinregularexpressions">Use Case: Multiline Strings in Regular Expressions</h2>
<p>Regular expressions (regex) are a powerful tool for pattern matching and manipulation of strings. In JavaScript, you might come across a situation where you need to use multiline strings in your regex patterns.</p>
<p>For instance, let's say you want to match a pattern that spans multiple lines. Here's how you can do it:</p>
<pre><code class="hljs"><span class="hljs-keyword">let</span> multilineString = <span class="hljs-string">`This is line one
and this is line two
and this is line three`</span>;

<span class="hljs-keyword">let</span> regex = <span class="hljs-regexp">/line one\nand this is line two/g</span>;

<span class="hljs-keyword">let</span> result = multilineString.match(regex);

<span class="hljs-built_in">console</span>.log(result);
</code></pre>
<p>The output of the above code will be:</p>
<pre><code class="hljs">[ &#x27;line one\nand this is line two&#x27; ]
</code></pre>
<p>The <code>\n</code> in the regex pattern signifies a newline character, which allows the pattern to span multiple lines.</p>

            <div class="alert alert-note">
                <div class="flex">
                    
                        <div class="flex-shrink-0 mr-3">
                            <img src="/assets/images/icon-information-circle-solid.svg" class="icon" aria-hidden="true" />
                        </div>
                        
                    <div class="w-full">
            <p><strong>Note:</strong> When using multiline strings in regex, it's important to remember that JavaScript's regex engine treats the <code>^</code> and <code>$</code> anchors as the start and end of the entire string, not individual lines. If you want to match the start or end of a line within a multiline string, you should use the multiline flag (<code>m</code>).</p>

                    </div>
                </div>
            </div>
            <h2 id="potentialissues">Potential Issues</h2>
<p>While multiline strings in JavaScript can really improve readability, and thus maintainability, of your code, there are a few pitfalls that you should be aware of.</p>
<p>First, leading and trailing white spaces can often cause problems. For instance, consider the following code:</p>
<pre><code class="hljs"><span class="hljs-keyword">let</span> str = <span class="hljs-string">`Hello,
           World!`</span>;

<span class="hljs-built_in">console</span>.log(str);
</code></pre>
<p>The output would be:</p>
<pre><code class="hljs">Hello,
           World!
</code></pre>
<p>As you can see, the leading white spaces are preserved in the output. To avoid this, you need to move the second line to the beginning of that line:</p>
<pre><code class="hljs"><span class="hljs-keyword">let</span> str = <span class="hljs-string">`Hello,
World!`</span>;

<span class="hljs-built_in">console</span>.log(str);
</code></pre>
<p>This would then give you the expected output:</p>
<pre><code class="hljs">Hello,
World!
</code></pre>
<p>The main problem with this is that it forces you to use un-natural indentation, and thus hurts the readability of your code.</p>
<p>Second, if you are using template literals for multiline strings, you should be aware that any JavaScript expression within the <code>${}</code> syntax will be evaluated. This could potentially lead to code injection if the string content comes from an untrusted source.</p>

            <div class="alert alert-warn">
                <div class="flex">
                    
                        <div class="flex-shrink-0 mr-3">
                            <img src="/assets/images/icon-exclamation-solid.svg" class="icon" aria-hidden="true" />
                        </div>
                        
                    <div class="w-full">
            <p><strong>Wait!</strong> Always validate and sanitize input when using template literals with content from an untrusted source to prevent potential code injection.</p>

                    </div>
                </div>
            </div>
            <p>Last, multiline strings may not be supported in all environments. While most modern browsers support ES6, older browsers or certain server-side environments may not. In these cases, you will need to transpile your code using a tool like <a href="https://babeljs.io/" rel="nofollow noopener" target="_blank">Babel</a>.</p>
<h2 id="conclusion">Conclusion</h2>
<p>In this article, we've explored how to create multiline strings in JavaScript, both using the traditional method and the ES6 way. We've also looked at how to use heredocs and variations of multiline strings.</p>
<p>We then saw some use cases of multiline strings in template literals and regular expressions, and highlighted potential issues that you might encounter.</p>


Creating Multiline Strings in JavaScript

Hidden Features of Python

<h2 id="introduction">Introduction</h2>
<p>In most programming languages, data can be read from various sources, like files, databases, or user input. However, one of the most common forms of input is the standard input, or stdin.</p>
<p>This article will provide a few different ways for reading from stdin in Python, which is an important skill for any developer working on command-line interfaces.</p>
<h2 id="whatisstdin">What is stdin?</h2>
<p>Standard input, commonly referred to as stdin, is a stream from which a program reads its input data. It's one of the three standard streams in computer systems, alongside stdout (standard output) and stderr (standard error). By default, stdin refers to the data that a user inputs from the keyboard.</p>

            <div class="alert alert-note">
                <div class="flex">
                    
                        <div class="flex-shrink-0 mr-3">
                            <img src="/assets/images/icon-information-circle-solid.svg" class="icon" aria-hidden="true" />
                        </div>
                        
                    <div class="w-full">
            <p><strong>Note:</strong> The concept of stdin, stdout, and stderr comes from Unix-like operating systems, but it's also available in other systems like Windows. They are used for inter-process communication and can be redirected, which is a significant feature in shell scripting and system programming.</p>

                    </div>
                </div>
            </div>
            <p>In Python, you can access stdin through the <code>sys.stdin</code> object, which behaves like a file object. This means you can use methods like <code>read()</code>, <code>readline()</code>, and <code>readlines()</code> to read from stdin, just as you would read from a file.</p>
<pre><code class="hljs"><span class="hljs-keyword">import</span> sys

<span class="hljs-keyword">for</span> line <span class="hljs-keyword">in</span> sys.stdin:
    <span class="hljs-built_in">print</span>(line)
</code></pre>
<p>In this simple example, the program will read from stdin line by line and print each line until it encounters an &quot;EOF&quot; (End of File) signal. You can send an EOF signal in the terminal by pressing <code>Ctrl+D</code> in Unix-like systems or <code>Ctrl+Z</code> in Windows.</p>
<h2 id="whyreadfromstdin">Why read from stdin?</h2>
<p>Standard input, or stdin, is a fundamental concept in computer programming that refers to the default data stream from which a program reads its input data. But why would you want to read from stdin instead of another source?</p>
<p>Well, reading from stdin is a common way to allow for dynamic user input during the program execution. It's also a way to receive data piped from another program. For example, let's say you have a program that processes text in some way, and you want to be able to use it in a Unix pipeline to process the output of another program. Reading from stdin is the way to go.</p>
<h2 id="howtoreadfromstdininpython">How to Read from stdin in Python</h2>
<p>Python, like most programming languages, provides a few different ways to read from stdin. We'll explore a couple of the most common methods in the following sections.</p>
<h3 id="usingsysstdin">Using sys.stdin</h3>
<p>The <code>sys.stdin</code> object in Python is a file-like object that acts as the stdin stream for the Python program. You can read from this stream just like you would read from a file.</p>
<p>Here's an example:</p>
<pre><code class="hljs"><span class="hljs-keyword">import</span> sys

line = sys.stdin.readline()

<span class="hljs-comment"># Removing the trailing newline character</span>
line = line.strip()

<span class="hljs-built_in">print</span>(<span class="hljs-string">f&quot;Received: <span class="hljs-subst">{line}</span>&quot;</span>)
</code></pre>
<p>In this code, we simply use <code>stdin</code>'s <code>readline()</code> method to get input from the user. The line is then printed out with the prefix &quot;Received: &quot;.</p>
<p>If you run this code and type in some input, you'll see that it echoes back each line you enter:</p>
<pre><code class="hljs"><span class="hljs-meta">$</span><span class="bash"> python read_stdin.py</span>
Hello, world!
Received: Hello, world!
</code></pre>
<h3 id="usingtheinputfunction">Using the <em>input()</em> Function</h3>
<p>The <code>input()</code> function is a simpler way to read a line of input from stdin. This function reads a line of input, converts it to a string (stripping the trailing newline), and returns that string.</p>
<p>Here's an example:</p>
<pre><code class="hljs">line = <span class="hljs-built_in">input</span>()
<span class="hljs-built_in">print</span>(<span class="hljs-string">&quot;Received: &quot;</span> + line)
</code></pre>
<p>Again, if you run this code and type in some input, you'll see that it echoes back the line you enter:</p>
<pre><code class="hljs"><span class="hljs-meta">$</span><span class="bash"> python read_input.py</span>
Hello, world!
Received: Hello, world!
</code></pre>
<p>The <code>input()</code> function always returns a string. If you want to read a number or some other type of data, you'll need to convert the string to that type using a function like <code>int()</code> or <code>float()</code>.</p>

            <div class="alert alert-reference">
                <div class="flex">
                    
                        <div class="flex-shrink-0 mr-3">
                            <img src="/assets/images/icon-link-solid.svg" class="icon" aria-hidden="true" />
                        </div>
                        
                    <div class="w-full">
            <p><strong>Link:</strong> For more information on how to read and convert data to the correct formats, see the following articles:</p>
<ul>
<li><a target="_blank" href="https://stackabuse.com/python-check-if-variable-is-a-number/">Python: Check if Variable is a Number</a></li>
<li><a target="_blank" href="https://stackabuse.com/check-if-string-contains-a-number-in-python/">Check if String Contains a Number in Python</a></li>
<li><a target="_blank" href="https://stackabuse.com/how-to-check-if-a-string-is-empty-or-none-in-python/">How to Check if a String is Empty or None in Python</a></li>
</ul>

                    </div>
                </div>
            </div>
            <h2 id="readingmultiplelinesfromstdin">Reading Multiple Lines from stdin</h2>
<p>In Python, reading multiple lines from stdin can be accomplished in a couple of ways. One common approach is to use a <code>for</code> loop with <code>sys.stdin</code>. This allows you to iterate over each line that is entered until an EOF (End of File) character is received.</p>
<p>Here's an example:</p>
<pre><code class="hljs"><span class="hljs-keyword">import</span> sys

<span class="hljs-keyword">for</span> line <span class="hljs-keyword">in</span> sys.stdin:
    <span class="hljs-built_in">print</span>(line)
</code></pre>
<p>In this code, each line that is entered into stdin will be printed out. The program will continue to read lines until an EOF character is received. You can simulate this by pressing <code>Ctrl+D</code> in the terminal.</p>
<p>Another way to read multiple lines of input from stdin is by using the <code>input()</code> function inside a loop. This is a more user-friendly approach since it waits for the user to press <code>Enter</code> before reading the next line.</p>
<p>Here's how you can do it:</p>
<pre><code class="hljs"><span class="hljs-keyword">while</span> <span class="hljs-literal">True</span>:
    <span class="hljs-keyword">try</span>:
        line = <span class="hljs-built_in">input</span>()
        <span class="hljs-built_in">print</span>(line)
    <span class="hljs-keyword">except</span> EOFError:
        <span class="hljs-keyword">break</span>
</code></pre>
<p>In this case, the program will also continue to read lines until an EOF character is received.</p>

            <div class="alert alert-note">
                <div class="flex">
                    
                        <div class="flex-shrink-0 mr-3">
                            <img src="/assets/images/icon-information-circle-solid.svg" class="icon" aria-hidden="true" />
                        </div>
                        
                    <div class="w-full">
            <p><strong>Note:</strong> The <code>input()</code> function automatically strips the newline character at the end of the line, while <code>sys.stdin</code> does not.</p>

                    </div>
                </div>
            </div>
            <h2 id="readingspecificnumberofcharactersfromstdin">Reading Specific Number of Characters from stdin</h2>
<p>Sometimes, you might want to read a specific number of characters from stdin. This can be done using the <code>read()</code> method provided by <code>sys.stdin</code>. The <code>read()</code> method takes an integer as an argument, which specifies the number of characters to read.</p>
<p>Here's an example where we read 10 characters from stdin:</p>
<pre><code class="hljs"><span class="hljs-keyword">import</span> sys

chars = sys.stdin.read(<span class="hljs-number">10</span>)
<span class="hljs-built_in">print</span>(chars)
</code></pre>
<p>In this code, the program will read the first 10 characters of input and print them out. If less than 10 characters are entered, the program will wait for more input until it has read 10 characters. <code>stdin</code> has a <code>read()</code> function since it's a file-like object, thus, you can read only a given number of characters, just like you can with files.</p>

            <div class="alert alert-note">
                <div class="flex">
                    
                        <div class="flex-shrink-0 mr-3">
                            <img src="/assets/images/icon-information-circle-solid.svg" class="icon" aria-hidden="true" />
                        </div>
                        
                    <div class="w-full">
            <p><strong>Note:</strong> The <code>read()</code> method does not automatically strip newline characters, so if the input includes newline characters within the first 10 characters, they will be included in the output.</p>

                    </div>
                </div>
            </div>
            <p>Remember, the <code>input()</code> function can also be used to read a specific number of characters, but it works slightly differently. The <code>input()</code> function reads a line of input (up to the newline character), and then you can use slicing to get the desired number of characters.</p>
<p>Here's an example:</p>
<pre><code class="hljs">line = <span class="hljs-built_in">input</span>()
chars = line[:<span class="hljs-number">10</span>]
<span class="hljs-built_in">print</span>(chars)
</code></pre>
<p>In this case, the program will read a line of input, and then print the first 10 characters of that line. If the line is less than 10 characters long (not including the newline), the entire line will be printed.</p>
<h2 id="handlingeoferrorwhenreadingfromstdin">Handling EOFError when Reading from stdin</h2>
<p>While reading from stdin in Python, you might encounter an <code>EOFError</code>. This error is raised when one of the built-in functions like <code>input()</code> hits an end-of-file condition (EOF) without reading any data. This usually happens when you run a program that's expecting input but doesn't receive any. It's important to handle this error in your code to prevent your program from crashing unexpectedly.</p>
<p>Here's how you can gracefully handle an EOFError:</p>
<pre><code class="hljs"><span class="hljs-keyword">try</span>:
    data = <span class="hljs-built_in">input</span>()
<span class="hljs-keyword">except</span> EOFError:
    <span class="hljs-built_in">print</span>(<span class="hljs-string">&quot;EOFError encountered. No input received.&quot;</span>)
</code></pre>
<p>In this code, we use a try-except block to catch and handle the <code>EOFError</code>. If <code>input()</code> hits an EOF condition, the program prints a message instead of crashing.</p>
<h2 id="conclusion">Conclusion</h2>
<p>Reading from stdin is a fundamental task in Python programming, especially when dealing with command-line applications or scripts. In this article, we've explored what stdin is, why you might want to read from it, and how to do so using various methods. We've also covered how to handle an <code>EOFError</code>, which can occur when reading from stdin. Understanding these concepts will help you create more robust, reliable Python applications.</p>


Reading from stdin in Python

Transitioning from jQuery to AngularJS

<h2 id="introduction">Introduction</h2>
<p>Working with data is a big part of any data analysis project. In Python, the Pandas library is a powerful tool that provides flexible and efficient data structures to make the process of data manipulation and analysis easier. One of the most common data structures provided by Pandas is the DataFrame, which can be thought of as a table of data with rows and columns. However, often you'll want to save your DataFrame to a file for later use, or to share with others. One of the most common file formats for data storage is CSV.</p>
<p>In this article, we'll explore how to write a <code>pandas</code> DataFrame to a CSV file.</p>
<h2 id="whywriteadataframetoacsvfile">Why Write a DataFrame to a CSV File?</h2>
<p>CSV files are a popular choice for data storage for a number of reasons. First and foremost, they are text-based and therefore human-readable. This means you can open a CSV file in a plain text editor to quickly view and understand the data it contains.</p>
<p>CSV files are also widely used and understood by many different software applications. This makes it easy to share data between different systems and programming languages. If you're working with a team that uses a variety of tools, saving your DataFrame to a CSV file ensures that everyone can work with the data.</p>
<p>Finally, writing a DataFrame to a CSV file is a way to persist your data. When you're working in a Python session, your DataFrame exists only in memory. If you close your Python session, your DataFrame is lost. By writing it to a CSV file, you can save your data to disk, allowing you to access it again later, even after you've closed and reopened your Python session.</p>
<pre><code class="hljs"><span class="hljs-keyword">import</span> pandas <span class="hljs-keyword">as</span> pd

<span class="hljs-comment"># Create a simple DataFrame</span>
df = pd.DataFrame({
    <span class="hljs-string">&#x27;A&#x27;</span>: [<span class="hljs-number">1</span>, <span class="hljs-number">2</span>, <span class="hljs-number">3</span>],
    <span class="hljs-string">&#x27;B&#x27;</span>: [<span class="hljs-string">&#x27;a&#x27;</span>, <span class="hljs-string">&#x27;b&#x27;</span>, <span class="hljs-string">&#x27;c&#x27;</span>]
})

<span class="hljs-comment"># Write DataFrame to CSV file</span>
df.to_csv(<span class="hljs-string">&#x27;my_data.csv&#x27;</span>)
</code></pre>
<p>In this code, a DataFrame is created and then written to a CSV file named <code>my_data.csv</code>. After running this code, you'll find a new file in your current directory with this name, containing the data from your DataFrame.</p>
<h2 id="howtowriteadataframetoacsvfile">How to Write a DataFrame to a CSV File</h2>
<p>Pandas, a popular Python data manipulation library, provides a simple yet powerful method to write a DataFrame to a CSV file. The function <code>to_csv()</code> is what we need.</p>
<p>Let's start with a basic DataFrame:</p>
<pre><code class="hljs"><span class="hljs-keyword">import</span> pandas <span class="hljs-keyword">as</span> pd

data = {<span class="hljs-string">&#x27;Name&#x27;</span>: [<span class="hljs-string">&#x27;John&#x27;</span>, <span class="hljs-string">&#x27;Anna&#x27;</span>, <span class="hljs-string">&#x27;Peter&#x27;</span>],
        <span class="hljs-string">&#x27;Age&#x27;</span>: [<span class="hljs-number">28</span>, <span class="hljs-number">24</span>, <span class="hljs-number">33</span>],
        <span class="hljs-string">&#x27;Country&#x27;</span>: [<span class="hljs-string">&#x27;USA&#x27;</span>, <span class="hljs-string">&#x27;Sweden&#x27;</span>, <span class="hljs-string">&#x27;Germany&#x27;</span>]}
df = pd.DataFrame(data)
</code></pre>
<p>Our DataFrame looks like this:</p>
<pre><code class="hljs">   Name  Age    Country
0  John   28        USA
1  Anna   24     Sweden
2  Peter  33    Germany
</code></pre>
<p>To write this DataFrame to a CSV file, we use the <code>to_csv()</code> function like so:</p>
<pre><code class="hljs">df.to_csv(<span class="hljs-string">&#x27;data.csv&#x27;</span>)
</code></pre>
<p>This will create a CSV file named <code>data.csv</code> in your current directory.</p>
<p>If you want to specify a different location, provide the full path. For example, <code>df.to_csv('/path/to/your/directory/data.csv')</code>.</p>
<h2 id="writingdataframetocsvwithspecificdelimiter">Writing DataFrame to CSV with Specific Delimiter</h2>
<p>By default, the <code>to_csv()</code> function uses a comma as the field delimiter. However, you can specify a different delimiter using the <code>sep</code> parameter.</p>
<p>For example, let's write our DataFrame to a CSV file using a semicolon as the delimiter:</p>
<pre><code class="hljs">df.to_csv(<span class="hljs-string">&#x27;data_semicolon.csv&#x27;</span>, sep=<span class="hljs-string">&#x27;;&#x27;</span>)
</code></pre>
<p>This will create a CSV file named <code>data_semicolon.csv</code> with the data separated by semicolons.</p>
<pre><code class="hljs">Name;Age;Country
John;28;USA
Anna;24;Sweden
Peter;33;Germany
</code></pre>

            <div class="alert alert-note">
                <div class="flex">
                    
                        <div class="flex-shrink-0 mr-3">
                            <img src="/assets/images/icon-information-circle-solid.svg" class="icon" aria-hidden="true" />
                        </div>
                        
                    <div class="w-full">
            <p><strong>Note:</strong> The <code>sep</code> parameter accepts any character as a delimiter. However, common delimiters are comma, semicolon, tab (<code>\t</code>), and space (' ').</p>

                    </div>
                </div>
            </div>
            <p>This flexibility of pandas allows you to easily write your DataFrame to a CSV file that suits your needs, whether it's a standard CSV or a CSV with a specific delimiter.</p>
<h2 id="writingdataframetocsvwithoutindex">Writing DataFrame to CSV Without Index</h2>
<p>By default, when you write a DataFrame to a CSV file using the <code>to_csv()</code> function, pandas includes the DataFrame's index. However, there may be scenarios where you don't want this. In such cases, you can set the <code>index</code> parameter to <code>False</code> to exclude the index from the CSV file.</p>
<p>Here's an example:</p>
<pre><code class="hljs"><span class="hljs-keyword">import</span> pandas <span class="hljs-keyword">as</span> pd

<span class="hljs-comment"># Create a simple dataframe</span>
df = pd.DataFrame({
   <span class="hljs-string">&#x27;A&#x27;</span>: [<span class="hljs-string">&#x27;foo&#x27;</span>, <span class="hljs-string">&#x27;bar&#x27;</span>, <span class="hljs-string">&#x27;baz&#x27;</span>],
   <span class="hljs-string">&#x27;B&#x27;</span>: [<span class="hljs-string">&#x27;alpha&#x27;</span>, <span class="hljs-string">&#x27;beta&#x27;</span>, <span class="hljs-string">&#x27;gamma&#x27;</span>]
})

<span class="hljs-built_in">print</span>(df)

df.to_csv(<span class="hljs-string">&#x27;no_index.csv&#x27;</span>, index=<span class="hljs-literal">False</span>)
</code></pre>
<p>The <code>print(df)</code> command will output:</p>
<pre><code class="hljs">     A      B
0  foo  alpha
1  bar   beta
2  baz  gamma
</code></pre>
<p>But the <code>no_index.csv</code> file will look like this:</p>
<pre><code class="hljs">A,B
foo,alpha
bar,beta
baz,gamma
</code></pre>
<p>As you can see, the CSV file does not include the DataFrame's index.</p>
<p>If you open the CSV file in a text editor, you may not see the DataFrame's index. However, if you open the CSV file in a spreadsheet program like Excel, you will see the index as the first column.</p>
<h2 id="handlingspecialcases">Handling Special Cases</h2>
<p>There are a few special cases you may come across when writing a DataFrame to a CSV file.</p>
<h3 id="handlingnanvalues">Handling NaN Values</h3>
<p>By default, pandas will write <code>NaN</code> values to the CSV file. However, you can change this behavior using the <code>na_rep</code> parameter. This parameter allows you to specify a string that will replace <code>NaN</code> values.</p>
<p>Here's an example:</p>
<pre><code class="hljs"><span class="hljs-keyword">import</span> pandas <span class="hljs-keyword">as</span> pd
<span class="hljs-keyword">import</span> numpy <span class="hljs-keyword">as</span> np

<span class="hljs-comment"># Create a simple dataframe with NaN values</span>
df = pd.DataFrame({
   <span class="hljs-string">&#x27;A&#x27;</span>: [<span class="hljs-string">&#x27;foo&#x27;</span>, np.nan, <span class="hljs-string">&#x27;baz&#x27;</span>],
   <span class="hljs-string">&#x27;B&#x27;</span>: [<span class="hljs-string">&#x27;alpha&#x27;</span>, <span class="hljs-string">&#x27;beta&#x27;</span>, np.nan]
})

df.to_csv(<span class="hljs-string">&#x27;nan_values.csv&#x27;</span>, na_rep=<span class="hljs-string">&#x27;NULL&#x27;</span>)
</code></pre>
<p>In the <code>nan_values.csv</code> file, <code>NaN</code> values are replaced with <code>NULL</code>:</p>
<pre><code class="hljs">,A,B
0,foo,alpha
1,NULL,beta
2,baz,NULL
</code></pre>
<h3 id="writingasubsetofthedataframetocsv">Writing a Subset of the DataFrame to CSV</h3>
<p>Sometimes, you may want to write only a subset of the DataFrame to the CSV file. You can do this using the <code>columns</code> parameter. This parameter allows you to specify a list of column names that you want to include in the CSV file.</p>
<p>Here's an example:</p>
<pre><code class="hljs"><span class="hljs-keyword">import</span> pandas <span class="hljs-keyword">as</span> pd

<span class="hljs-comment"># Create a simple dataframe</span>
df = pd.DataFrame({
   <span class="hljs-string">&#x27;A&#x27;</span>: [<span class="hljs-string">&#x27;foo&#x27;</span>, <span class="hljs-string">&#x27;bar&#x27;</span>, <span class="hljs-string">&#x27;baz&#x27;</span>],
   <span class="hljs-string">&#x27;B&#x27;</span>: [<span class="hljs-string">&#x27;alpha&#x27;</span>, <span class="hljs-string">&#x27;beta&#x27;</span>, <span class="hljs-string">&#x27;gamma&#x27;</span>],
   <span class="hljs-string">&#x27;C&#x27;</span>: [<span class="hljs-number">1</span>, <span class="hljs-number">2</span>, <span class="hljs-number">3</span>]
})

df.to_csv(<span class="hljs-string">&#x27;subset.csv&#x27;</span>, columns=[<span class="hljs-string">&#x27;A&#x27;</span>, <span class="hljs-string">&#x27;B&#x27;</span>])
</code></pre>
<p>The <code>subset.csv</code> file will include only the 'A' and 'B' columns:</p>
<pre><code class="hljs">,A,B
0,foo,alpha
1,bar,beta
2,baz,gamma
</code></pre>
<p>Remember, <code>pandas</code> is a powerful library and provides many options for writing DataFrames to CSV files. Be sure to check out the <a href="https://pandas.pydata.org/pandas-docs/stable/reference/api/pandas.DataFrame.to_csv.html" rel="nofollow noopener" target="_blank">official documentation</a> to learn more.</p>
<h2 id="conclusion">Conclusion</h2>
<p>In this tutorial, we have explored the power of pandas and its ability to write DataFrame to a CSV file. We've learned the basic method of writing a DataFrame to a CSV file, how to specify a delimiter, and how to write a DataFrame to a CSV file without the index. We've also looked at handling special cases in writing a DataFrame to a CSV file.</p>


Writing a Pandas DataFrame to a CSV File in Python

<h2 id="introduction">Introduction</h2>
<p>Python, being a high-level, interpreted language, is known for its easy readability with great design principles. However, when you delve deeper into Python, some things may seem complex if you're coming from a language that doesn't have a similar feature. One such feature is the concept of magic methods, and in this Byte, we're going to demystify what <code>__str__</code> and <code>__repr__</code> magic methods are, their differences, and why and when to use each.</p>
<h2 id="whataremagicmethods">What are Magic Methods?</h2>
<p>Magic methods in Python are special methods that add &quot;magic&quot; to your classes. They're always surrounded by double underscores (e.g. <code>__init__</code> or <code>__lt__</code>). These methods are also known as dunder methods, short for &quot;double under.&quot; Magic methods are not meant to be invoked directly by you, but the invocation happens internally from the class on a certain action. For instance, when you add two numbers using the <code>+</code> operator, internally, the <code>__add__</code> method will be called.</p>
<pre><code class="hljs"><span class="hljs-class"><span class="hljs-keyword">class</span> <span class="hljs-title">Number</span>:</span>
    <span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">__init__</span>(<span class="hljs-params">self, num</span>):</span>
        self.num = num

    <span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">__add__</span>(<span class="hljs-params">self, other</span>):</span>
        <span class="hljs-keyword">return</span> self.num + other.num

num1 = Number(<span class="hljs-number">2</span>)
num2 = Number(<span class="hljs-number">3</span>)

<span class="hljs-built_in">print</span>(num1 + num2)  <span class="hljs-comment"># Output: 5</span>
</code></pre>
<p>In the example above, you can see that the <code>__add__</code> method is being used to enable the use of the <code>+</code> operator. This is the magic of magic methods!</p>
<p>Magic methods can make your classes act more like Python built-in types, and make your code more intuitive and cleaner.</p>
<h2 id="understanding__str__method">Understanding __str__ Method</h2>
<p>The <code>__str__</code> method in Python represents the &quot;informal&quot; or nicely printable string representation of an object. This method is called by the <code>str()</code> built-in function and by the <code>print</code> function to convert the object into a string.</p>
<p>Let's take a look at an example where we define a <code>Person</code> class with a <code>__str__</code> method:</p>
<pre><code class="hljs"><span class="hljs-class"><span class="hljs-keyword">class</span> <span class="hljs-title">Person</span>:</span>
    <span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">__init__</span>(<span class="hljs-params">self, name, age</span>):</span>
        self.name = name
        self.age = age

    <span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">__str__</span>(<span class="hljs-params">self</span>):</span>
        <span class="hljs-keyword">return</span> <span class="hljs-string">f&#x27;Person(name=<span class="hljs-subst">{self.name}</span>, age=<span class="hljs-subst">{self.age}</span>)&#x27;</span>

p = Person(<span class="hljs-string">&#x27;John Doe&#x27;</span>, <span class="hljs-number">30</span>)
<span class="hljs-built_in">print</span>(p)
</code></pre>
<p>The output of this code would be:</p>
<pre><code class="hljs">Person(name=John Doe, age=30)
</code></pre>
<p>In this example, the <code>__str__</code> method returns a string that represents the <code>Person</code> object in a human-readable form.</p>
<h2 id="understanding__repr__method">Understanding __repr__ Method</h2>
<p>On the other hand, the <code>__repr__</code> method returns a string that describes a precise, unambiguous representation of an object. The main goal of this method is to be explicit about the object's information. It's meant to be used in debugging and development. The <code>__repr__</code> method is called by the <code>repr()</code> built-in function.</p>
<p>Here's an example where we define a <code>Person</code> class with a <code>__repr__</code> method:</p>
<pre><code class="hljs"><span class="hljs-class"><span class="hljs-keyword">class</span> <span class="hljs-title">Person</span>:</span>
    <span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">__init__</span>(<span class="hljs-params">self, name, age</span>):</span>
        self.name = name
        self.age = age

    <span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">__repr__</span>(<span class="hljs-params">self</span>):</span>
        <span class="hljs-keyword">return</span> <span class="hljs-string">f&#x27;Person(name=<span class="hljs-subst">{self.name!r}</span>, age=<span class="hljs-subst">{self.age!r}</span>)&#x27;</span>

p = Person(<span class="hljs-string">&#x27;John Doe&#x27;</span>, <span class="hljs-number">30</span>)
<span class="hljs-built_in">print</span>(<span class="hljs-built_in">repr</span>(p))
</code></pre>
<p>The output of this code would be:</p>
<pre><code class="hljs">Person(name=&#x27;John Doe&#x27;, age=30)
</code></pre>
<p>In this example, the <code>__repr__</code> method returns a string that if evaluated, would produce an object equivalent to <code>p</code>. Notice the use of <code>!r</code> in the format string to ensure the output string uses <code>repr()</code> instead of <code>str()</code>. This is part of the attempt to make the output unambiguous.</p>

            <div class="alert alert-note">
                <div class="flex">
                    
                        <div class="flex-shrink-0 mr-3">
                            <img src="/assets/images/icon-information-circle-solid.svg" class="icon" aria-hidden="true" />
                        </div>
                        
                    <div class="w-full">
            <p><strong>Note:</strong> If you don't define a <code>__str__</code> method in your class, Python will call the <code>__repr__</code> method when attempting to print an object.</p>

                    </div>
                </div>
            </div>
            <h2 id="differencesbetween__str__and__repr__">Differences Between __str__ and __repr__</h2>
<p>In Python, <code>__str__</code> and <code>__repr__</code> are two magic methods that serve different purposes. At first glance, they might seem similar as they both return a string representation of the object. However, the key difference between them lies in their intended audience and the level of detail they provide.</p>
<p>The <code>__str__</code> method is meant to provide a concise, human-readable description of an object. It's what you’ll see when you print an object. On the other hand, <code>__repr__</code> is intended to provide a complete and unambiguous representation of the object, which is more useful for developers. It's what you’ll see when you display the object in the console.</p>
<p>Here's an example to illustrate this difference:</p>
<pre><code class="hljs"><span class="hljs-class"><span class="hljs-keyword">class</span> <span class="hljs-title">Person</span>:</span>
    <span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">__init__</span>(<span class="hljs-params">self, name, age</span>):</span>
        self.name = name
        self.age = age

    <span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">__str__</span>(<span class="hljs-params">self</span>):</span>
        <span class="hljs-keyword">return</span> <span class="hljs-string">f&#x27;<span class="hljs-subst">{self.name}</span> is <span class="hljs-subst">{self.age}</span> years old.&#x27;</span>

    <span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">__repr__</span>(<span class="hljs-params">self</span>):</span>
        <span class="hljs-keyword">return</span> <span class="hljs-string">f&#x27;Person(<span class="hljs-subst">{self.name}</span>, <span class="hljs-subst">{self.age}</span>)&#x27;</span>

p = Person(<span class="hljs-string">&#x27;John&#x27;</span>, <span class="hljs-number">30</span>)

<span class="hljs-built_in">print</span>(p)  <span class="hljs-comment"># John is 30 years old.</span>
p  <span class="hljs-comment"># Person(John, 30)</span>
</code></pre>
<p>Here, <code>print(p)</code> invokes the <code>__str__</code> method and returns a human-readable string. However, when you type <code>p</code> in the console, Python calls the <code>__repr__</code> method and returns a more detailed string that could be used to recreate the object.</p>
<h2 id="whyandwhentouse__str__">Why and When to Use __str__</h2>
<p>The <code>__str__</code> method is primarily used for creating a human-readable representation of the object. It's a great way to provide a simple summary or description of the object that can easily be understood by end users.</p>
<p>You might want to use <code>__str__</code> when you're printing objects for logging or debugging purposes, or when you want to display a friendly message to the user. For example, if you're developing a game, you might use <code>__str__</code> to print a player's stats in a readable format.</p>
<p>Here's how you might use <code>__str__</code> in a game:</p>
<pre><code class="hljs"><span class="hljs-class"><span class="hljs-keyword">class</span> <span class="hljs-title">Player</span>:</span>
    <span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">__init__</span>(<span class="hljs-params">self, name, level, health</span>):</span>
        self.name = name
        self.level = level
        self.health = health

    <span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">__str__</span>(<span class="hljs-params">self</span>):</span>
        <span class="hljs-keyword">return</span> <span class="hljs-string">f&#x27;Player <span class="hljs-subst">{self.name}</span> is at level <span class="hljs-subst">{self.level}</span> with <span class="hljs-subst">{self.health}</span> health points.&#x27;</span>

player = Player(<span class="hljs-string">&#x27;Hero&#x27;</span>, <span class="hljs-number">10</span>, <span class="hljs-number">100</span>)

<span class="hljs-built_in">print</span>(player)  <span class="hljs-comment"># Player Hero is at level 10 with 100 health points.</span>
</code></pre>
<p>In this example, the <code>__str__</code> method returns a string that provides a concise summary of the player's current status. This makes it easy for users to understand the player's status at a glance.</p>
<h2 id="whyandwhentouse__repr__">Why and When to Use __repr__</h2>
<p>The <code>__repr__</code> method in Python is a special method that returns a string representing a printable version of an object. But when would you use it? Well, <code>__repr__</code> is intended to be unambiguous and complete. This means that if you have an object, the <code>__repr__</code> of that object should contain all the information necessary to recreate the object if fed back into the interpreter.</p>
<p>This makes <code>__repr__</code> incredibly useful for debugging and logging, as it can provide a more detailed overview of an object compared to <code>__str__</code>. If you're working with complex data structures, or need a complete representation of your object for troubleshooting, <code>__repr__</code> is the way to go.</p>

            <div class="alert alert-note">
                <div class="flex">
                    
                        <div class="flex-shrink-0 mr-3">
                            <img src="/assets/images/icon-information-circle-solid.svg" class="icon" aria-hidden="true" />
                        </div>
                        
                    <div class="w-full">
            <p><strong>Note:</strong> In the absence of a defined <code>__str__</code> method, Python will default to using <code>__repr__</code> when the <code>print()</code> function is called on an object.</p>

                    </div>
                </div>
            </div>
            <h2 id="examplesusingthe__str__method">Examples: Using the __str__ Method</h2>
<p>Now that we've discussed the <code>__repr__</code> method, let's switch gears and look at some examples of how you might use the <code>__str__</code> method in Python. Remember, <code>__str__</code> is meant to return a nicely printable string representation of an object, making it great for end-user output.</p>
<p>Let's define a simple <code>Person</code> class with <code>__str__</code> method:</p>
<pre><code class="hljs"><span class="hljs-class"><span class="hljs-keyword">class</span> <span class="hljs-title">Person</span>:</span>
    <span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">__init__</span>(<span class="hljs-params">self, name, age</span>):</span>
        self.name = name
        self.age = age

    <span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">__str__</span>(<span class="hljs-params">self</span>):</span>
        <span class="hljs-keyword">return</span> <span class="hljs-string">f&#x27;Person(name=<span class="hljs-subst">{self.name}</span>, age=<span class="hljs-subst">{self.age}</span>)&#x27;</span>
</code></pre>
<p>Now, let's create an instance of <code>Person</code> and print it:</p>
<pre><code class="hljs">p = Person(<span class="hljs-string">&#x27;John&#x27;</span>, <span class="hljs-number">28</span>)
<span class="hljs-built_in">print</span>(p)
</code></pre>
<p>Output:</p>
<pre><code class="hljs">Person(name=John, age=28)
</code></pre>
<p>As you can see, the <code>print()</code> function calls the <code>__str__</code> method and prints a user-friendly string representation of our <code>Person</code> object. This can be very useful when you want to present object information in a readable and clean format.</p>
<h2 id="examplesusingthe__repr__method">Examples: Using the __repr__ Method</h2>
<p>Let's dive into some examples to understand the usage of <strong>repr</strong> in Python. Consider a class called &quot;Person&quot; with a few attributes.</p>
<pre><code class="hljs"><span class="hljs-class"><span class="hljs-keyword">class</span> <span class="hljs-title">Person</span>:</span>
    <span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">__init__</span>(<span class="hljs-params">self, name, age</span>):</span>
        self.name = name
        self.age = age
</code></pre>
<p>If we create an instance of this class and try to print it, we'll get an unhelpful message.</p>
<pre><code class="hljs">p = Person(<span class="hljs-string">&#x27;John Doe&#x27;</span>, <span class="hljs-number">30</span>)
<span class="hljs-built_in">print</span>(p)
</code></pre>
<p>Output:</p>
<pre><code class="hljs">&lt;__main__.Person object at 0x7f3f8e7e3d30&gt;
</code></pre>
<p>This is where <strong>repr</strong> comes in handy. Let's override the <strong>repr</strong> method in our class.</p>
<pre><code class="hljs"><span class="hljs-class"><span class="hljs-keyword">class</span> <span class="hljs-title">Person</span>:</span>
    <span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">__init__</span>(<span class="hljs-params">self, name, age</span>):</span>
        self.name = name
        self.age = age

    <span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">__repr__</span>(<span class="hljs-params">self</span>):</span>
        <span class="hljs-keyword">return</span> <span class="hljs-string">f&#x27;Person(name=<span class="hljs-subst">{self.name}</span>, age=<span class="hljs-subst">{self.age}</span>)&#x27;</span>
</code></pre>
<p>Now, when we create an instance of the class and print it, we get a much more meaningful output.</p>
<pre><code class="hljs">p = Person(<span class="hljs-string">&#x27;John Doe&#x27;</span>, <span class="hljs-number">30</span>)
<span class="hljs-built_in">print</span>(p)
</code></pre>
<p>Output:</p>
<pre><code class="hljs">Person(name=John Doe, age=30)
</code></pre>
<p>The <code>__repr__</code> method should return a string that is a valid Python expression. It's meant to be unambiguous and complete. This means that if you were to copy its output and run it, you should get the same object that was printed.</p>
<h2 id="conclusion">Conclusion</h2>
<p><code>__str__</code> and <code>__repr__</code> are special methods in Python that allow us to control how objects are converted to strings. While <code>__str__</code> is meant for creating a readable string representation for end users, <code>__repr__</code> is designed to generate an unambiguous string representation for developers. Understanding the difference between these two methods and when to use each one is crucial for writing clean, effective Python code.</p>
<p>Whether you're debugging or displaying data, these magic methods can make your life a lot easier. Remember, it's always a good practice to implement <code>__repr__</code> for your classes, and implement <code>__str__</code> if you think it would be useful to have a string version of the object that's user-friendly.</p>


The Python Magic Methods: __str__ vs __repr__

<h2 id="introduction">Introduction</h2>
<p>When you're knee-deep in Python code, comprehensive documentation can be a lifesaver (but, admittedly, the last thing you want to write). It's an important part of programming, and Python, being a highly readable and straightforward language, places great emphasis on it.</p>
<p>One key component of Python documentation is the docstring, a unique feature that sets Python apart from many other languages. In this article, we'll delve into what a docstring is and explore some of the most common docstring formats used in Python.</p>
<h2 id="whatisadocstring">What is a Docstring?</h2>
<p>A docstring, short for documentation string, is a literal string used right after the definition of a function, method, class, or module. It captures the essence of what the function does, providing an easy reference for the programmer. In Python, a docstring is a first-class citizen, meaning it can be accessed programmatically using the <code>__doc__</code> attribute.</p>
<p>Here's a simple Python function with a docstring:</p>
<pre><code class="hljs"><span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">add_numbers</span>(<span class="hljs-params">a, b</span>):</span>
    <span class="hljs-string">&quot;&quot;&quot;
    Adds two numbers together.

    Args:
        a (int): The first number.
        b (int): The second number.

    Returns:
        int: The sum of the two numbers.
    &quot;&quot;&quot;</span>
    <span class="hljs-keyword">return</span> a + b
</code></pre>
<p>And here's how you can access the docstring:</p>
<pre><code class="hljs"><span class="hljs-built_in">print</span>(add_numbers.__doc__)
</code></pre>
<p>The output will be:</p>
<pre><code class="hljs">Adds two numbers together.

Args:
    a (int): The first number.
    b (int): The second number.

Returns:
    int: The sum of the two numbers.
</code></pre>

            <div class="alert alert-note">
                <div class="flex">
                    
                        <div class="flex-shrink-0 mr-3">
                            <img src="/assets/images/icon-information-circle-solid.svg" class="icon" aria-hidden="true" />
                        </div>
                        
                    <div class="w-full">
            <p><strong>Note:</strong> Python's built-in <code>help()</code> function can also be used to access the docstring of a function, method, class, or module. For instance, <code>help(add_numbers)</code> will print the docstring along with some additional information.</p>

                    </div>
                </div>
            </div>
            <p>There's really no strict rule on how to write a docstring, although several widely accepted formats make the docstrings more structured and useful. These formats not only help in understanding the code, but they also allow tools like Sphinx, PyDoc, and Doxygen to automatically generate well-formatted documentation.</p>
<p>We'll look at these formats in the following sections.</p>
<h2 id="commonpythondocstringformats">Common Python Docstring Formats</h2>
<p>Docstrings in Python are a powerful tool for documenting your code. They're essentially comments that are written in a specific format, which allows them to be parsed by documentation generation tools. There are several common formats for writing docstrings, and they each have their own strengths and weaknesses. The most commonly used formats are reStructuredText (reST), Google, NumPy/SciPy, and Epytext.</p>

            <div class="alert alert-note">
                <div class="flex">
                    
                        <div class="flex-shrink-0 mr-3">
                            <img src="/assets/images/icon-information-circle-solid.svg" class="icon" aria-hidden="true" />
                        </div>
                        
                    <div class="w-full">
            <p><strong>Note:</strong> It's important to keep in mind that the best docstring format for you depends on your specific use case. You should consider factors like the complexity of your code, the tools you're using to generate documentation, and your personal preference.</p>

                    </div>
                </div>
            </div>
            <h2 id="restructuredtextrestdocstringformat">ReStructured Text (reST) Docstring Format</h2>
<p>ReStructuredText, often abbreviated as reST, is a file format for textual data used primarily in the Python community for technical documentation. It's the default plaintext markup language used by Sphinx, a Python documentation generator.</p>
<p>In a reST docstring, you would typically start with a brief description of the function's purpose. You would then include sections for <code>:param:</code> to describe input parameters, <code>:returns:</code> to describe the return value, and <code>:raises:</code> to describe any exceptions that the function may raise.</p>
<p>Here's an example of what a reST docstring might look like:</p>
<pre><code class="hljs"><span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">add_numbers</span>(<span class="hljs-params">x, y</span>):</span>
    <span class="hljs-string">&quot;&quot;&quot;
    Adds two numbers together.

    :param x: The first number to add
    :type x: int or float
    :param y: The second number to add
    :type y: int or float
    :returns: The sum of x and y
    :rtype: int or float
    :raises ValueError: If either x or y is not an int or float
    &quot;&quot;&quot;</span>
    <span class="hljs-keyword">if</span> <span class="hljs-keyword">not</span> <span class="hljs-built_in">isinstance</span>(x, (<span class="hljs-built_in">int</span>, <span class="hljs-built_in">float</span>)) <span class="hljs-keyword">or</span> <span class="hljs-keyword">not</span> <span class="hljs-built_in">isinstance</span>(y, (<span class="hljs-built_in">int</span>, <span class="hljs-built_in">float</span>)):
        <span class="hljs-keyword">raise</span> ValueError(<span class="hljs-string">&#x27;Both x and y must be ints or floats&#x27;</span>)
    <span class="hljs-keyword">return</span> x + y
</code></pre>
<p>In this example, the docstring starts with a brief description of the function. It then uses <code>:param:</code> to describe the input parameters <code>x</code> and <code>y</code>, <code>:type:</code> to specify their types, <code>:returns:</code> to describe the return value, and <code>:raises:</code> to describe the <code>ValueError</code> exception that the function may raise.</p>

            <div class="alert alert-note">
                <div class="flex">
                    
                        <div class="flex-shrink-0 mr-3">
                            <img src="/assets/images/icon-information-circle-solid.svg" class="icon" aria-hidden="true" />
                        </div>
                        
                    <div class="w-full">
            <p><strong>Note:</strong> With reST, you can also include other sections like <code>:example:</code> for examples of usage, <code>:seealso:</code> for related functions, and <code>:note:</code> for additional notes. This makes it a very flexible and comprehensive documentation tool.</p>

                    </div>
                </div>
            </div>
            <h2 id="googledocstringformat">Google Docstring Format</h2>
<p>The Google Docstring format is a popular choice among Python developers due to its readability and simplicity. This format is characterized by a clear separation of sections, which are indicated by section headers. Section headers include <code>Args</code>, <code>Returns</code>, <code>Raises</code>, <code>Yields</code>, and <code>Attributes</code>, among others.</p>
<p>Here's an example of a function documented using the Google Docstring format:</p>
<pre><code class="hljs"><span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">add_numbers</span>(<span class="hljs-params">a, b</span>):</span>
    <span class="hljs-string">&quot;&quot;&quot;
    Adds two numbers together.

    Args:
        a (int): The first number.
        b (int): The second number.

    Returns:
        int: The sum of a and b.
    &quot;&quot;&quot;</span>
    <span class="hljs-keyword">return</span> a + b
</code></pre>
<p>Here, the <code>Args</code> section describes the arguments the function expects, including their type and purpose. The <code>Returns</code> section, on the other hand, describes the result that the function returns, along with its type.</p>
<h2 id="numpyscipydocstringformat">NumPy/SciPy Docstring Format</h2>
<p>The NumPy/SciPy Docstring format is another popular format, especially among scientific computing communities. It provides a structured way to document Python code and is characterized by its extensive use of sections and sub-sections, which makes it suitable for documenting complex code.</p>
<p>Here's an example of a function documented using the NumPy/SciPy Docstring format:</p>
<pre><code class="hljs"><span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">add_numbers</span>(<span class="hljs-params">a, b</span>):</span>
    <span class="hljs-string">&quot;&quot;&quot;
    Adds two numbers together.

    Parameters
    ----------
    a : int
        The first number.
    b : int
        The second number.

    Returns
    -------
    int
        The sum of a and b.
    &quot;&quot;&quot;</span>
    <span class="hljs-keyword">return</span> a + b
</code></pre>
<p>In this example, the <code>Parameters</code> section describes the function's parameters, including their type and purpose. The <code>Returns</code> section describes the result that the function returns, along with its type. The use of dashes (<code>------</code>) to separate sections is a distinctive feature of this format.</p>

            <div class="alert alert-note">
                <div class="flex">
                    
                        <div class="flex-shrink-0 mr-3">
                            <img src="/assets/images/icon-information-circle-solid.svg" class="icon" aria-hidden="true" />
                        </div>
                        
                    <div class="w-full">
            <p><strong>Note:</strong> Both the Google and NumPy/SciPy Docstring formats are supported by various tools for generating documentation, like Sphinx and Pydoc. This means that you can automatically generate HTML, PDF, or other formats of documentation from your Python docstrings.</p>

                    </div>
                </div>
            </div>
            <h2 id="epytextdocstringformat">EpYtext Docstring Format</h2>
<p>EpYtext is another popular docstring format used in Python. It's a plain text format for Python docstrings that was developed as part of the Epydoc project. Epytext markup language is designed to be easy to read and write in its raw form, yet easy to render in a variety of output formats.</p>
<p>Here's an example of how to use the EpYtext docstring format:</p>
<pre><code class="hljs"><span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">add_numbers</span>(<span class="hljs-params">a, b</span>):</span>
    <span class="hljs-string">&quot;&quot;&quot;
    This function adds two numbers.

    @param a: The first number.
    @type a: C{int}
    @param b: The second number.
    @type b: C{int}
    @return: The sum of the two numbers.
    @rtype: C{int}
    &quot;&quot;&quot;</span>
    <span class="hljs-keyword">return</span> a + b
</code></pre>
<p>In the above example, you can see that the EpYtext format uses <code>@</code>-style tags to denote different sections of the docstring. The <code>@param</code> and <code>@type</code> tags are used to document the function parameters, while the <code>@return</code> and <code>@rtype</code> tags are used to document the return value of the function.</p>
<h2 id="choosingtherightdocstringformat">Choosing the Right Docstring Format</h2>
<p>Choosing the right docstring format is largely a matter of personal preference and the specific needs of your project. However, there are a few things to consider when making your decision.</p>
<p>Firstly, consider the complexity of your project. If your project is large and complex, a more structured docstring format like reST or NumPy/SciPy might be beneficial. These formats allow for more detailed documentation, which can be especially helpful in large codebases.</p>
<p>Secondly, consider the tools you're using. Some documentation generation tools, like Sphinx, have better support for certain docstring formats. For example, Sphinx has built-in support for the reST docstring format.</p>
<p>Thirdly, consider the readability of the docstring format. Some developers find certain formats easier to read and write than others. For example, some people find the Google docstring format to be more readable than the reST format.</p>
<p>Here's a quick comparison of the four docstring formats we've discussed:</p>
<ul>
<li><strong>reST</strong>: Highly structured, great for complex projects, excellent support in Sphinx.</li>
<li><strong>Google</strong>: Less structured, easy to read and write, good support in various tools.</li>
<li><strong>NumPy/SciPy</strong>: Highly structured, great for scientific projects, excellent support in Sphinx.</li>
<li><strong>EpYtext</strong>: Less structured, easy to read and write, good support in Epydoc.</li>
</ul>
<p>Remember, the most important thing is that you're documenting your code. The specific format you choose is less important than the act of documentation itself.</p>
<h2 id="conclusion">Conclusion</h2>
<p>In this article, we've taken a deep dive into the world of Python docstrings and explored some of the most common formats that developers use to document their code. We've looked at the ReStructured Text (reST), Google, NumPy/SciPy, and Epytext docstring formats, each with their own unique styles and conventions.</p>
<p>Choosing the right docstring format largely depends on your specific project needs and personal preference. Whether you prefer the simplicity of Google's style, the detailed structure of reST, or the mathematical focus of NumPy/SciPy, remember that the key to good documentation is consistency and clarity. As long as your docstrings are clear, concise, and consistent, they will serve as a useful guide for both you and other developers who interact with your code.</p>


Python Naming Conventions for Variables, Functions, and Classes

Creating Multiline Strings in JavaScript

Hidden Features of Python

Reading from stdin in Python

Transitioning from jQuery to AngularJS

Writing a Pandas DataFrame to a CSV File in Python

The Python Magic Methods: str vs repr

Common Docstring Formats in Python

Shuffling Arrays in JavaScript