[MOVE] Shifting the code of module level __dir__ and __attr__ method to another blog post.

Author: ultimatecoder

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

@@ -29,14 +29,13 @@ In this post, I will try to discuss improvements done in Core Python version
 
   * 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.
+    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
 
-    Below is the example of using breakpoints in your program:
+    Below is the example of using putting breakpoint in your program:
 
     # Note: A Gif will be more batter example for this.
     ```python
@@ -48,18 +47,25 @@ In this post, I will try to discuss improvements done in Core Python version
     ...
     ```
 
+    Explaination:
+
+    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.
+
   * PYTHONBREAKPOINT environment variable:
 
-    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.
+    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.
 
     # TODO: Add demonstration of gif for this point.
 
-    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.
+    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.
 
 
 * Subprocess got new parameter capture_output:
@@ -68,16 +74,16 @@ In this post, I will try to discuss improvements done in Core Python version
   stream (stderr) by enabling capture_output parameter of subprocess.run
   command.
 
-  Without this parameter, capturing the Standard stream was lengthy using
-  subprocess.PIPE parameter like below
+  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 shorten like below
+  With capture_output parameter, this will become more concise like below
 
   ```python
   subprocess.run(["ls", "-l", "/var"], capture_output=True)
@@ -107,7 +113,7 @@ In this post, I will try to discuss improvements done in Core Python version
   ```
 
 
-* Dataclasses:
+* 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
@@ -116,7 +122,9 @@ In this post, I will try to discuss improvements done in Core Python version
   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.
+  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:
@@ -129,8 +137,13 @@ In this post, I will try to discuss improvements done in Core Python version
   <__main__.Point object at 0x7f3c73688b00>
   ```
 
-  Converting above example with```@dataclass``` decorator below and then I will
-  discuss some more advantages of using a dataclass decorator.
+  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
@@ -144,47 +157,25 @@ In this post, I will try to discuss improvements done in Core Python version
   Point(x=2, y=4)
   ```
 
-  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.
+  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
   ```
 
-* 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.
-
-* __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
-  Class.
-
-    # TODO: Example of __attr__ at module level.
+  Explanation:
 
+  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.
 
-    I request to share your views on this post. If you think I have missed any
-    important point, or something is confusing I request you to write me at
-    [[email protected]](mailto:[email protected]). I will be happy to find
-    improvements on me. Thanks for reading :)
 
 * Default arguments to Namedtuples:
 
@@ -207,3 +198,14 @@ In this post, I will try to discuss improvements done in Core Python version
   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.
+
+
+
+* .pyc files are now diffed with 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.