Python: Amazing Features
Tags: python, programming, amazing, features
Published: 2020-12-30 15:30:45

Hello, here we are to discuss some amazing features of python which are making python magical.

##1. Getting Code of Python Object

In python, we can get the internal implementation of the python object by using `inspect` module. It is used to introspect live objects in a program and look at the source code of modules, classes, and functions that are used throughout a program. This is powerful because this module can actually be used to extract the source code of a function itself, parse the arguments which that function accepts, and related library documentation.

For example:

**Source Code:**
![Alt Text](https://dev-to-uploads.s3.amazonaws.com/i/bg8umvkq6ajldbjxp69c.png)

For getting code of complete module:
>![Alt Text](https://dev-to-uploads.s3.amazonaws.com/i/ju315t35ljf49q0r0vzw.png)
**Output**
![Alt Text](https://dev-to-uploads.s3.amazonaws.com/i/sbocs1sgqlxk22g591k4.png)

For getting code of a class or method:
>![Alt Text](https://dev-to-uploads.s3.amazonaws.com/i/yd1uavk77bxfqq7qxdn1.png)
**Output**
![Alt Text](https://dev-to-uploads.s3.amazonaws.com/i/uo92dtfpzsqkshrv3nua.png)

##2. `exec()` function in Python

`exec()` function is used for the dynamic execution of Python program which can either be a string or object code. If it is a string, the string is parsed as a suite of Python statements which is then executed unless a syntax error occurs and if it is an object code, it is simply executed. We must be careful that the return statements may not be used outside of function definitions not even within the context of code passed to the `exec()` function. It doesn't returns any value, hence returns `None`.

####Syntex of `exec()`:
```
exec(object[, globals[, locals]])
```
####Parameters: 
* __object :-__ this can be a string or object code
* __globals :-__This can be a dictionary and the parameter is optional
* __locals :-__This can be a mapping object and is also optional


>The `exec()` function accepts large blocks of code, unlike the `eval()` function which only accepts a single expression

####Example:
```
x = 'name = "John"\nprint(name)'
exec(x)
```
####Output:
```
John
```

##3.`__call__` methode in Python
Python has a set of built-in methods and `__call__` is one of them. The `__call__` method enables Python programmers to write classes where the instances behave like functions and can be called like a function. This means we can call a class object as a function. That is an amazing benefit of python and feels like magic. There is too much confusion in function, class, and instances so see this using example.

####Example :
![Alt Text](https://dev-to-uploads.s3.amazonaws.com/i/7kbpjppaiz5x1na47gnw.png)
####Output:
```
Instance Created
200
```
##4. Metaclass
A metaclass in Python is a class of a class that defines how a class behaves. A class is itself an instance of a metaclass. A class in Python defines how the instance of the class will behave. In order to understand metaclasses well, one needs to have prior experience working with Python classes. Before we dive deeper into metaclasses, let's get a few concepts out of the way.

###Creating Custom Metaclasses
In Python, we can customize the class creation process by passing the metaclass keyword in the class definition. This can also be done by inheriting a class that has already passed in this keyword.

```
class MyMeta(type):
    pass

class MyClass(metaclass=MyMeta):
    pass

class MySubclass(MyClass):
    pass
```
We can see below that the type of MyMeta class is type and that the type of MyClass and MySubClass is MyMeta.
####Code:
```
print(type(MyMeta))
print(type(MyClass))
print(type(MySubclass))
```
####Output:
```
<class 'type'>
<class '__main__.MyMeta'>
<class '__main__.MyMeta'>
```
>"Metaclasses are deeper magic than 99% of users should ever worry about. If you wonder whether you need them, you don’t (the people who actually need them know with certainty that they need them, and don’t need an explanation about why)."

##5. Dataclass

One new and exciting feature coming in Python 3.7 is the data class. A data class is a class typically containing mainly data, although there aren’t really any restrictions. It is created using the new @dataclass decorator, as follows:

```
from dataclasses import dataclass

@dataclass
class DataClassCard:
    rank: str
    suit: str
```
A data class comes with basic functionality already implemented. For instance, you can instantiate, print, and compare data class instances straight out of the box:
```
>>> queen_of_hearts = DataClassCard('Q', 'Hearts')
>>> queen_of_hearts.rank
```
####Output:
`'Q'`

Thanks for reading