[IMPROVE] Blog post of writing data classes.

Author: ultimatecoder

_posts/2018-08-12-walkthrough-with-features-introduced-in-core-python-3-7.md

@@ -9,16 +9,11 @@ tag:
 ---
 
 
-In this post, I will try to discuss improvements done in Core Python version 3.7. Below is the summary of features convered in this post.
-
-* Fstrings
+In this post, I will try to discuss improvements done in Core Python version
+3.7. Below is the summary of features convered in this post.
 
 * Breakpoints
 
-* Disabling breakpoints using environment variable
-
-* namedtuples
-
 * subprocess
 
 * dataclass
@@ -27,108 +22,69 @@ In this post, I will try to discuss improvements done in Core Python version 3.7
 
 * __dir__ and __attr__ at module level. Inside __init__.py file
 
+* namedtuples
 
-* Fstring: Fstring is one of the coolest feature introduced with this version of
-  Python. F-String is yet another way of re-presenting formatted strings. At
-  present, Python already have more than two ways to format string. This version
-  do introduce yet another way to format the strings. In my view, this option is
-  more concise than the other available options.
 
-  ```python
-  >>> name = "Jay"
-  >>> print(f"Hello {name}")
-  Hello Jay
-  >>> name = "Vijay"
-  >>> print(f"Hello {name}")
-  Hello Vijay
-  ```
+* Breakpoint:
 
-  You have to append **f** before the starting of the formatted string. The
-  variable substitution will be done by looking for the value of that variable
-  inside the present scope. If, the variable isn't defined that it will raise a
-  NameError.
+  * breakpoint():
 
+    Breakpoints are extream important feature for debugging. Since I
+    started learning Python, I am using the same API of putting breakpoints. With
+    latest improvements, you can put breakpoints by calling the function
+    "breakpoint()". The ```breakpoint`` is a built in function. Calling buildting
+    function is more handy than its previous way which is importing a
+    ```set_trace``` method from the ```pdb``` module.
 
-* Breakpoint: Breakpoints are extream important feature for debugging. Since, I
-  started learning Python I am using the same API of putting breakpoints. With
-  latest improvements, you can put breakpoints by calling the function
-  "breakpoint()". Yes, ```breakpoint`` is a built in function now. You don't
-  need to import ```pdb``` and call ```pdb.set_trace``` anymore.
+    Below is the example of using breakpoints in your program:
 
-  Example
-  ```python
-  >>> for i in range(5):
-  ...     if i % 2 == 0:
-  ...         breakpoint()
-  ...     else:
-  ...         print(i)
-  ...
-  > <stdin>(1)<module>()
-  (Pdb) c
-  1
-  > <stdin>(1)<module>()
-  (Pdb) c
-  3
-  > <stdin>(1)<module>()
-  (Pdb) c
-  ```
+    # Note: A Gif will be more batter example for this.
+    ```python
+    >>> for i in range(5):
+    ...     if i % 2 == 0:
+    ...         breakpoint()
+    ...     else:
+    ...         print(i)
+    ...
+    ```
 
-* Disabling breakpoint with environment variable: Have you felt anytime that you
-  are debugging your code and you have added lost of breakpoints. Now, you want
-  to disable them for a moment. Removing them is time consuming and putting them
-  back is too. Now, it is possible to disable all the breakpoints of your code
-  by just setting an environment variable named "PYTHONBREAKPOINT=0". When you
-  want to enable them again, you can either unset the value of this environment
-  variable or set the value of it to "1".
+  * PYTHONBREAKPOINT environment variable:
 
-  # TODO: Add video demonstration or gif demonstration for this.
+    You can disable all the breakpoints by setting this environment variable to
+    "1". Sometimes debugging can lead to a level where number of breakpoints are
+    too many. This environment variable can provide a great way of toggling them
+    in one shot.
 
+    # TODO: Add demonstration of gif for this point.
 
-* Default arguments to Namedtuples: Namedtuples are less known, but very helpful
-  feature of Python. I use them whenever I constructing a Class is lengthy, but
-  I want to expose it as an instance.
+    I advise to set "PYTHONBREAKPOINT=0" at production environment. That will
+    prevent long holding if someone someone forgets to remove a breakpoint from
+    their code and deploys it to production. I have seen people doing this.
 
-  ```python
-  >>> from collections import namedtuple
-  >>> Point = namedtuple("Point", ["x", "y"], defaults=[2,])
-  >>> p = Point(3)
-  >>> p
-  Point(x=3, y=2)
-  ```
 
-  One important point to observe here is that the default arguments will be
-  assigned in the order of left to right. Here, the default argument **2** will
-  be assigned to **y**, and not **x**.
+* Subprocess got new parameter capture_output:
 
-* Subprocess got new parameter named *capture_output*: We all use
-  ```subprocess.run``` a lot for running various commands. For capturing the
-  output of Standard output stream (stdout) and Standard error stream, we have
-  to pipe them with existing subprocess module. Like below
+  You can pipe the output of Standard Output stream (stdout) and Standard Error
+  stream (stderr) by enabling capture_output parameter of subprocess.run
+  command.
 
-  ```python
-  >>> import subprocess
-  >>> ls = subprocess.run(["ls", "-l", "/var"], stdout=subprocess.PIPE, stderr=subprocess.PIPE)
-  >>> print(ls.stdout.decode())
-  total 28
-  drwxr-xr-x 11 root root 4096 Apr 24 15:14 cache
-  drwxr-xr-x  4 root root 4096 Aug 12 15:28 db
-  drwxr-xr-x  2 root root 4096 Jul  2 13:47 empty
-  drwxr-xr-x 34 root root 4096 Jul 20 04:22 lib
-  lrwxrwxrwx  1 root root    9 Oct 12  2017 lock -> /run/lock
-  drwxr-xr-x 11 root root 4096 Aug 12 14:52 log
-  lrwxrwxrwx  1 root root   15 Apr 23 14:08 mail -> /var/spool/mail
-  lrwxrwxrwx  1 root root    4 Oct 12  2017 run -> /run
-  drwxr-xr-x  7 root root 4096 Jun 15 09:22 spool
-  drwxrwxrwt  3 root root 4096 Aug 10 15:15 tmp
+  Without this parameter, capturing the Standard stream was lengthy using
+  subprocess.PIPE parameter like below
 
-  >>> print(ls.stderr.decode())
+  ```python
+  subprocess.run(
+    ["ls", "-l", "/var"], stdout=subprocess.PIPE, stderr=subprocess.PIPE
+  )
+  ```
 
+  With capture_output parameter, this will become shorten like below
 
+  ```python
+  subprocess.run(["ls", "-l", "/var"], capture_output=True)
   ```
 
-  With this version, you can get exact output by just passing this option
-  ```capture_output=True``` to ```subprocess.run(...)```. Below is the example
-  for this.
+  Below is the detailed example of using captured_true parameter with
+  subprocess.run command.
 
   ```python
   >>> import subprocess
@@ -151,11 +107,14 @@ In this post, I will try to discuss improvements done in Core Python version 3.7
   ```
 
 
-* Dataclass decorator: This new decorator will reduce many lines of your code.
-  Python is known for such improvements. For understanding this more, you should
-  be aware with Python's latest feature of providing type hints. I will try to
-  write a tutorial on type hints in up coming days. Until there, I will suggest
-  to grab any inital tutorial from your Google search.
+* Dataclasses:
+
+  The new class level decorator "@dataclass" will reduce many lines of your
+  code. Python is well known for developing features which allows to achieve
+  more by writing less. For understanding this feature batter, you should be
+  aware of type hints. I will try to write a tutorial on type hints in up coming
+  days. Until there, I will suggest to grab any available tutorial from your
+  Google search.
 
   Below is the usual way to define a Class and creating an object from it.
 
@@ -170,7 +129,8 @@ In this post, I will try to discuss improvements done in Core Python version 3.7
   <__main__.Point object at 0x7f3c73688b00>
   ```
 
-  Above lines can be reduced with using ```@dataclass``` decorator.
+  Converting above example with```@dataclass``` decorator below and then I will
+  discuss some more advantages of using a dataclass decorator.
 
   ```python
   >>> from dataclasses import dataclass
@@ -184,32 +144,35 @@ In this post, I will try to discuss improvements done in Core Python version 3.7
   Point(x=2, y=4)
   ```
 
-  Those lines of putting construct for obious things is gone! Additionally, the
-  class level decorator ```@dataclass``` is defining dundre methods like
-  ```__repr__()``` and ```__eq__()``` and ```__hash__()``` for us.
+  Those lines of putting obious construct code is gone! Additionally, the class
+  level decorator ```@dataclass``` is authomatically defining behaviours for
+  dundre methods ```__repr__()```, ```__eq__()``` and ```__hash__()```
+  for us. I will advise of using this decorator for defining your Classes.
 
 
-* Putting underscores in defining Integers: Writing large numbers as value in
-  code is difficult to read. I myself put finger on screen and count the places
-  to get an idea of number. In this version, you can add put *_* for values.
-  Below example will make it more clear.
+* Putting underscores in defining Integers:
+
+  Writing large numbers as value in code is difficult to read. I myself put
+  finger on screen and count the places to get an idea of number. In this
+  version, you can add put *_* for values.  Below example will make it more
+  clear.
 
   ```python
   >>> x = 1_00_000
   >>> x
   100000
   ```
 
-* Module level definition of dunder methods __dir__() and __attr__(): I was
-  facing this issue of hinding actual imports of my module with user. It was
-  always confusing when someone calls "dir()" on my modules. There is already
-  dunder method called "__dir__()" to override this behaviour, but this method
-  was limited to Classes. With this version, it is possible to override the
-  behaviour of module by defining module level ```__dir__()``` method.
+* Module level definition of dunder methods __dir__() and __attr__():
 
+  I was facing this issue of hinding actual imports of my module with user. It
+  was always confusing when someone calls "dir()" on my modules. There is
+  already dunder method called "__dir__()" to override this behaviour, but this
+  method was limited to Classes. With this version, it is possible to override
+  the behaviour of module by defining module level ```__dir__()``` method.
 
-    # TODO: Write the example of them here.
 
+    # TODO: Write the example of them here.
 
 * __attr__ : You can override this method for various purposes like firing an
   API deprication warning. The method will behave just as it was behaving on
@@ -222,3 +185,25 @@ In this post, I will try to discuss improvements done in Core Python version 3.7
     important point, or something is confusing I request you to write me at
     [jaysinhp@gmail.com](mailto:jaysinhp@gmail.com). I will be happy to find
     improvements on me. Thanks for reading :)
+
+* Default arguments to Namedtuples:
+
+  Namedtuples are less known, but very helpful feature of Python. I use them
+  whenever I find constructing a Class can be lengthy, still I want to mimic the
+  Class behaviour.
+
+  Below is the example of putting a default arguments to a named tuple:
+
+  ```python
+  >>> from collections import namedtuple
+  >>> Point = namedtuple("Point", ["x", "y"], defaults=[2,])
+  >>> p = Point(3)
+  >>> p
+  Point(x=3, y=2)
+  ```
+
+  Explanation:
+
+  The default arguments will be assigned in to attributes in the order from left
+  to right. Here, the default argument 2 will be assigned to y, and not
+  x.