Gain insights into advanced Python 3, learn the Pythonic Way, explore data structures, functional and object-oriented paradigms, and master iterables, generators, and coroutines through practical projects.

python3.tar.gz

python3

python3-copy

This highly interactive and advanced course will give you insight into the most common Python tricks and tips. This course is for practicing Python programmers who are aiming for proficiency in Python 3. If you want to switch from Python 2 to Python 3, this is your go-to course. 

This course will help you learn the Pythonic Way of writing code and leveraging advanced robust features to become more proficient than the average developer. You’ll start by covering Python’s built-in data structures, and then you’ll move on to different programming paradigms like functional programming and object-oriented programming. 

In the latter half of the course, you’ll focus on iterables, generators, and coroutines. You’ll also have the opportunity to work on two projects to help strengthen what you learn. In all, this course is perfect for anyone who wants to become a confident and competent Pythonista by picking up the idioms and practical tips.

Mastering the Art of Programming in Python 3

In this section, we'll create a metaclass without `type()`. To create a _custom_ metaclass we have to inherit `type` metaclass and override `__init__()` and `__new__()`.

# Overriding the methods

Before overriding the methods, let's first get an overview on their functionality.

+ `__new__`: It creates a _new_ object and returns it. Before the control goes to `__init__()`, `__new__()` is called.

+ `__init__`: It _initializes_ the created object.

## Example
Let's code an example.

# Defining a class
class A: 
  pass

# Defining our own new method
def new(cls):
  x = object.__new__(cls)
  x.attr = 1
  return x

# override __new__() method
A.__new__ = new


# Making an object and testing
obj = A()
print(obj.attr)

In the above example, you can see that we make an empty class with no namespace. Then, we define a _class method_ `new` at __line 6__. This method creates a new object `x` of a class and initializes it by setting an instance variable `attr` to it before returning it.

Look at __line 12__. We are _overriding_ the `__new__` method of `A` with the `new` method we define above. The difference is that `__new__` only creates and returns the object and initialization is left for `__init__`. But now after overriding, the `__new__` will also do initialization (__line 8__). 

Then, in the end, we create an object of type `A` which calls the updated `__new__`. That's the reason we can successfully print the `attr` of the `obj` even we have no `__init__` defined anywhere in the program.

What if we try to override the `__new__` of `type` class? Python doesn't allow it.  All the classes are derived from the `type` metaclass. So, Python makes sure to keep it safe. If you want to customize the instantiation of a class, create your custom metaclass. Let's do it!

# Creating a metaclass of your own
Look at the following snippet.
```python3
class Meta(type):

  def __new__(cls, name, bases, dct):

    x = super().__new__(cls, name, bases, dct)
    x.attr = 1
    return x
```
Here, we define a class deriving from `type`. Remember,  a class deriving from a metaclass is also a metaclass. So, `Meta` is also a metaclass. We define the `__new__` method for this class. Here, we are calling `__new__` of `type` class (using the `super` keyword) to create a new class `x`. Then, we set a custom attribute `attr` to the created class, before returning that `x` class. 

Now, let's write a program for creating a class using this `Meta` custom metaclass.

Understand creating custom metaclasses in detail.

Introduction

Built-in Data Structures

Functional Programming

Project I: Data Science with Data Structures

Data science with Data Structures

Project I Review

Object-Oriented Idioms

Iterables and Generators

Coroutines

Project II: Build Your Own Matrix Module

Build Your Own Matrix Library

Project II Review

Meta-Programming

The End

Custom Meta-Classes

Overriding the methods