[INIT] Blog post describing latest improvements in Python 3.7

Author: ultimatecoder

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

@@ -0,0 +1,224 @@
+---
+layout: post
+title: "Walkthrough with features introduced in Core Python 3.7"
+date: "2018-08-12 15:51:15 +0530"
+tag:
+  - Python
+  - Core_python
+  - Python3.7
+---
+
+
+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
+
+* Breakpoints
+
+* Disabling breakpoints using environment variable
+
+* namedtuples
+
+* subprocess
+
+* dataclass
+
+* int with under_scores
+
+* __dir__ and __attr__ at module level. Inside __init__.py file
+
+
+* 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
+  ```
+
+  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()". Yes, ```breakpoint`` is a built in function now. You don't
+  need to import ```pdb``` and call ```pdb.set_trace``` anymore.
+
+  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
+  ```
+
+* 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".
+
+  # TODO: Add video demonstration or gif demonstration for this.
+
+
+* 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.
+
+  ```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 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
+
+  ```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
+
+  >>> print(ls.stderr.decode())
+
+
+  ```
+
+  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.
+
+  ```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())
+
+  ```
+
+
+* 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.
+
+  Below is the usual way to define a Class and creating an object from 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>
+  ```
+
+  Above lines can be reduced with using ```@dataclass``` decorator.
+
+  ```python
+  >>> from dataclasses import dataclass
+  >>> @dataclass
+  ... class Point:
+  ...     x: float
+  ...     y: float
+  ...
+  >>> p = Point(2, 4)
+  >>> p
+  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.
+
+
+* 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.
+
+
+    # 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.
+
+
+    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
+    [jaysinhp@gmail.com](mailto:jaysinhp@gmail.com). I will be happy to find
+    improvements on me. Thanks for reading :)