Adding a blog post explaining features introduced in Python 3.7

Author: ultimatecoder

_posts/2019-01-12-python-3-7-feature-walkthrough.md

@@ -0,0 +1,147 @@
+---
+layout: post
+title: "Python 3.7 feature walkthrough"
+date: "2019-01-12 16:20:41 +0530"
+tag:
+  - Python
+  - CorePython
+  - Python3.7
+---
+
+
+In this post, I will try to explain improvements done in Core Python version
+3.7. Below is the summary of features covered in this post.
+
+* Breakpoints
+
+* Subprocess
+
+* Dataclass
+
+* Int with underscores
+
+* Namedtuples
+
+* Hash-based Python object file
+
+### breakpoint()
+
+Breakpoint is an extremely important tool for debugging. Since I started
+learning Python, I am using the same API for putting breakpoints. With this
+release, ```breakpoint()``` is introduced as a built-in function. Because it is
+in a built-in scope, you don't have to import it from any module. You can call
+this function to put breakpoints in your code. This approach is handier  than
+importing ```pdf.set_trace()```.
+
+![Breakpoint function in Python 3.7](/assets/images/walkthrough_python_3_7/breakpoint_example.gif)
+
+Code used in above example
+
+```python
+for i in range(100):
+    if i == 10:
+        breakpoint()
+    else:
+        print(i)
+
+```
+
+### PYTHONBREAKPOINT
+
+There wasn't any handy option to
+disable or enable existing breakpoints with single flag. But with this release
+you can certainly reduce your pain by using ```PYTHONBREAKPOINT``` environment
+variable. You can disable all breakpoints in your code by setting the environment variable
+```PYTHONBREAKPOINT``` to ```0```.
+
+
+![Breakpoint environment variable in Python 3.7](/assets/images/walkthrough_python_3_7/breakpoint_environment_variable_example.gif)
+
+##### I advise to put "PYTHONBREAKPOINT=0" in your production environment to avoid unwanted pausing at forgotten breakpoints
+
+
+### Subprocess.run(capture_output=True)
+
+You can pipe the output of Standard Output Stream (stdout) and Standard Error
+Stream (stderr) by enabling ```capture_output``` parameter of
+```subprocess.run()``` function.
+
+![subprocess.run got capture_output parameter](/assets/images/walkthrough_python_3_7/subprocess_run_capture_output.gif)
+
+You should note that it is an improvement over piping the stream menually. For
+example, ```subprocess.run(["ls", "-l", "/var"], stdout=subprocess.PIPE,
+stderr=subprocess.PIPE)``` was the previous approach to capture the output of
+```stdout``` and ```stderr```.
+
+
+### Dataclasses
+
+The new class level decorator ```@dataclass``` introduced with ```dataclasses```
+module. Python is well-known for developing features which allows to achieving
+more by writing less. This module seems to get more updates in future which will
+reduce many lines of your code. Basic understanding of Typehints is expected to
+understand this feature.
+
+When you wrap your class with the ```@dataclass``` decorator, the decoractor
+will put obvious constructor code for you.  Additionally, it defines a behaviour
+for dander methods ```__repr__()```, ```__eq__()``` and ```__hash__()```.
+
+
+![Dataclasses.dataclass](/assets/images/walkthrough_python_3_7/dataclasses_dataclass.gif)
+
+Below is the code before introducing a ```dataclasses.dataclass``` decorator.
+
+```python
+class Point:
+
+    def __init__(self, x, y):
+        self.x = x
+        self.y = y
+```
+
+
+After wrapping with ```@dataclass``` decorator it reduces to below code
+
+```python
+from dataclasses import dataclass
+
+
+@dataclass
+class Point:
+    x: float
+    y: float
+```
+
+
+### Namedtuples
+
+The namedtuples are very helpful data structure, yet I found it is less known
+amongs developers. With this release, you can set default values to argument
+variables.
+
+![Namedtuples with default arguments](/assets/images/walkthrough_python_3_7/namedtuple_example.gif)
+
+##### Note: Default arguments will be assigned from left to right. In the above example, default value ``2`` will be assigned to variable ``y``
+
+Below is the code used in the example
+
+```python
+from collections import namedtuple
+
+
+Point = namedtuple("Point", ["x", "y"], defaults=[2,])
+p = Point(1)
+print(p)
+```
+
+### .pyc
+
+***.pyc** are object files generated everytime you change your code file (.py).
+It is collection of meta-data created by an interpreter for executed code.
+Interpreter will use this data when you re-execute this code next time. Present
+approach to identify an outdated object file is done by comparing meta fields of
+source code file like last edited date. With this release, that identification
+process is improved by comparing files using a hash-based approach. Hash based
+approach is quick and consistent accorss various platforms than comparing last
+edited dates.  This improvement is considered unstable. Core python will
+continue with the metadata approach and slowly migrate to hash based approach.