[FINALIZE] The blog post by correcting a grammar check. Pending uploding GIFs of demonstration.

Author: ultimatecoder

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

@@ -10,7 +10,7 @@ tag:
 
 
 In this post, I will try to explain improvements done in Core Python version
-3.7. Below is the summary of features convered in this post.
+3.7. Below is the summary of features covered in this post.
 
 * Breakpoints
 
@@ -22,187 +22,179 @@ In this post, I will try to explain improvements done in Core Python version
 
 * Namedtuples
 
-* Hashbased Python object file
-
+* Hash-based Python object file
 
 * Breakpoint:
 
-  * breakpoint():
+* breakpoint():
 
-    Breakpoints are extream important for debugging. Since I started learning
-    Python, I am using the same API of putting breakpoints. With this release,
-    breakpoint() is a new build-in function for putting breakpoints in your
-    code. This way is more handy than its previous way which is importing and
-    calling a set_trace method from the pdb module like pdb.set_trace
+Breakpoints are extream important for debugging. Since I started learning
+Python, I am using the same API for putting breakpoints. With this release,
+breakpoint() is a new built-in function for putting breakpoints in your code.
+This way is handier than its previous way which is importing and calling a
+set_trace method from the pdb module like pdb.set_trace
 
-    Below is the example of using putting breakpoint in your program:
+Below is the example of putting a breakpoint in your program:
 
-    # Note: A Gif will be more batter example for this.
-    ```python
-    >>> for i in range(5):
-    ...     if i % 2 == 0:
-    ...         breakpoint()
-    ...     else:
-    ...         print(i)
-    ...
-    ```
+# Note: A Gif will be more batter example for this.
 
-    Explaination:
+'''python
+>>> for i in range(5):
+... if i % 2 == 0:
+... breakpoint()
+... else:
+... print(i)
+...
+'''
 
-    The above code will take a pause by opening a Python Debugger (pdb) when the
-    value of iterator variable i will be even. All the odd values are printed on
-    screen.
+Explanation:
 
-  * PYTHONBREAKPOINT environment variable:
+The above code will take a pause by opening a Python Debugger (pdb) when the
+value of iterator variable i is even. All the odd values of it are printed on
+the screen.
 
-    You can disable all the breakpoints in your code by setting this environment
-    variable to "1". Sometimes debugging can lead to a level where number of
-    breakpoints are out of control. Process of finding, removing and re-ading a
-    breakpoint becomes overhead. This environment variable can provide a great
-    way of toggling them in one shot.
+* PYTHONBREAKPOINT environment variable:
 
-    # TODO: Add demonstration of gif for this point.
+You can disable all the breakpoints in your code by setting this environment
+variable to “1”. Sometimes debugging can lead to a level where a number of
+breakpoints are out of control. The process of finding, removing and reading
+breakpoints becomes an overhead. This environment variable can provide a great
+way of toggling them in one shot.
 
-    I advise to set "PYTHONBREAKPOINT=0" at production environment. This will
-    prevent your code from long holding if you merge a code with breakpoint by
-    mistake.
+# TODO: Add demonstration of GIF for this point.
 
+I advise setting "PYTHONBREAKPOINT=0" in the production environment. This will
+prevent your code from long holding if you merge a code with breakpoint by
+mistake.
 
 * Subprocess got new parameter capture_output:
 
-  You can pipe the output of Standard Output stream (stdout) and Standard Error
-  stream (stderr) by enabling capture_output parameter of subprocess.run
-  command.
-
-  Without this parameter, capturing the Standard streams was lengthy. Below is
-  the example by using subprocess.PIPE parameter
-
-  ```python
-  subprocess.run(
-    ["ls", "-l", "/var"], stdout=subprocess.PIPE, stderr=subprocess.PIPE
-  )
-  ```
-
-  With capture_output parameter, this will become more concise like below
-
-  ```python
-  subprocess.run(["ls", "-l", "/var"], capture_output=True)
-  ```
-
-  Below is the detailed example of using captured_true parameter with
-  subprocess.run command.
-
-  ```python
-  >>> import subprocess
-  >>> ls = subprocess.run(["ls", "-l", "/var"], capture_output=True)
-  >>> 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
-
-  >>> print(ls.stderr.decode())
-
+You can pipe the output of Standard Output stream (stdout) and Standard Error
+stream (stderr) by enabling capture_output parameter of subprocess.run
+command.
+
+Without this parameter, capturing the Standard streams was lengthy. Below is the example by using subprocess.PIPE parameter
+
+'''python
+subprocess.run(
+["ls", "-l", "/var"], stdout=subprocess.PIPE, stderr=subprocess.PIPE
+)
+'''
+
+With capture_output parameter, this will become more concise like below
+
+'''python
+subprocess.run(["ls", "-l", "/var"], capture_output=True)
+'''
+
+Below is the detailed example of using captured_true parameter with
+subprocess.run command.
+
+'''python
+>>> import subprocess
+>>> ls = subprocess.run(["ls", "-l", "/var"], capture_output=True)
+>>> 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
+
+>>> print(ls.stderr.decode())
 
 * Dataclasses module:
 
-  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. I
-  will explain how below approach can be reduced by wrapping a @dataclass
-  decorator to it.
-
-  ```python
-  >>> class Point:
-  ...     def __init__(self, x, y):
-  ...         self.x = x
-  ...         self.y = y
-  ... 
-  >>> p = Point(2, 4)
-  >>> p
-  <__main__.Point object at 0x7f3c73688b00>
-  ```
-
-  Converting above example with @dataclass decorator, Those lines of putting
-  odious construct code is gone! Additionally, the class level decorator
-  @dataclass will automatically define a behaviour for dander methods
-  __repr__(), __eq__() and __hash__() for us.
-
-  Below is the example code of wrapping Point class with @dataclass decorator
-  demonstrated earlier.
-
-  ```python
-  >>> from dataclasses import dataclass
-  >>> @dataclass
-  ... class Point:
-  ...     x: float
-  ...     y: float
-  ...
-  >>> p = Point(2, 4)
-  >>> p
-  Point(x=2, y=4)
-  ```
-
+The new class level decorator "@dataclass" will reduce many lines of your code.
+Python is well-known for developing features which allow achieving 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 upcoming days. Until
+there, I will suggest grabbing any available tutorial from Google.
+
+Below is the usual way to define a Class and creating an object from it. I will
+explain how below approach can be reduced by wrapping a @dataclass decorator to
+it.
+
+'''python
+&gt;&gt;&gt; class Point:
+... def __init__(self, x, y):
+... self.x = x
+... self.y = y
+...
+&gt;&gt;&gt; p = Point(2, 4)
+&gt;&gt;&gt; p
+<__main__.Point object at 0x7f3c73688b00>
+'''
+
+Converting above example with @dataclass decorator, Those lines of putting
+obvious construct code will gone! Additionally, it will define a behaviour for
+dander methods __repr__(), __eq__() and __hash__() for us.
+
+Below is the example code of wrapping Point class demonstrated earlier with
+@dataclass decorator.
+
+'''python
+&gt;&gt;&gt; from dataclasses import dataclass
+&gt;&gt;&gt; @dataclass
+... class Point:
+... x: float
+... y: float
+...
+&gt;&gt;&gt; p = Point(2, 4)
+&gt;&gt;&gt; p
+Point(x=2, y=4)
+'''
 
 * Putting underscores in defining Integers:
 
-  Writing large numbers as value invites a difficulty of reading it later. Many
-  times I myself put finger on screen and count the places to get an idea of
-  number. In this version, you can put _ for separating numbers for constructing
-  more readable value.  Below example will make more understanding to this.
-
-  ```python
-  >>> x = 1_00_000
-  >>> x
-  100000
-  ```
+Writing large numbers as value invites a difficulty of reading it later. Many
+times I myself put finger on the screen and count the places to get an idea of
+number. In this version, you can put _ for separating numbers for constructing
+more readable value. Below example will make more understanding of this.
 
-  Explanation:
+'''python
+&gt;&gt;&gt; x = 1_00_000
+&gt;&gt;&gt; x
+100000
+'''
 
-  The integer value of x is 1, 00, 000. Putting underscore at places of comma
-  makes larger value more readable than writing entire value together.
+Explanation:
 
+The integer value of x is 1, 00, 000. Putting underscore at places of a comma
+makes the larger value more readable than writing entire value together.
 
 * 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:
+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 behavior.
 
-  ```python
-  >>> from collections import namedtuple
-  >>> Point = namedtuple("Point", ["x", "y"], defaults=[2,])
-  >>> p = Point(3)
-  >>> p
-  Point(x=3, y=2)
-  ```
+Below is the example of putting a default arguments to a named tuple:
 
-  Explanation:
+'''python
+&gt;&gt;&gt; from collections import namedtuple
+&gt;&gt;&gt; Point = namedtuple("Point", ["x", "y"], defaults=[2,])
+&gt;&gt;&gt; p = Point(3)
+&gt;&gt;&gt; p
+Point(x=3, y=2)
+'''
 
-  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.
+Explanation:
 
+The default arguments will be assigned in the order from left to right. Here,
+the default argument 2 will be assigned to y, and not x.
 
-* .pyc files are now diffed with hash approach:
+* .pyc files are now diffed with the hash approach:
 
-  .pyc are object files generated everytime you change your Python code file
-  (.py). At present identifying the change in Python code is done by comparing
-  meta fields like edited date. With this release, that functionality is
-  improved by comparing files with hash based approach. Hashbased approach quick
-  and more consistent than a meta data approach. Though this improvment is still
-  considered unstable and CPython will continue with the meta data approach.
+.pyc are object files generated every time you change your Python code file
+(.py). At present identifying the change in Python code is done by comparing
+meta fields like an edited date and few other fields. With this release, that
+functionality is improved by comparing files with a hash-based approach. Hashed
+approach is quick and more consistent than a metadata approach. Though this
+improvement is still considered unstable and CPython will continue with the
+metadata approach with this release.