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

Custom metaclasses can modify classes by performing further actions or adding code. Usually, we do not require custom metaclasses, but sometimes they are necessary.

# Dynamic creation of a class

In the [previous lesson](https://www.educative.io/courses/mastering-the-art-of-programming-in-python-3/introduction-to-meta-programming#type-of-an-object), we examined the types of different objects by passing a single argument to the `type()` function. That's certainly not the end; this function can do much more. We can also create the classes using the `type()` function. Isn't this amazing?

We can also call `type()` with _three_ arguments:
```python3
type(<name>, <base>, <dct>)
```
+ The `<name>` is the _name_ of the class. If passed, it becomes the `__name__` attribute of the class. 
+ The `<base>` is the _tuple_ of the _base classes_ from which the class inherits. If passed, it becomes the `__base__` attribute of the class. 
+ The `<dct>` is the local _namespace_ of the class containing the definitions for the class body, which includes class methods and variables. If passed, it becomes the `__dict__` attribute of the class. 

# Creating classes with `type()`
Without any further ado, let's start creating dynamic classes by using different variations of `type()`.

## Variation I
Take the example of the following class:
```python3
class A:
  pass
```
Now let's create the same class dynamically.

Learn how to create classes with the type() function.

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

Dynamic Classes