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 exercise, we want to _time_ our functions. What we want is that whenever a class method executes, it should print the time taken by itself.

Let's get into detail. Consider the scenario below while attempting the challenge.

We have an `Animal` class. It has a function `talk` as follows:
```python3
class Animal():

    def talk(self):
        time.sleep(1)
        print("Animal talk")
```
And, we have a decorator `time_taken` that calculates the required time taken by any function.

Now, if we want to calculate the time for `talk`, we can simply add `@time_taken` before its header, and the problem is solved!

But what if we create child classes of `Animal` in the future and want to decorate all the functions of child classes? Adding `@time_taken` at the beginning of every definition would be time-taking and hectic. 

To avoid such a repetitive fuss, if we know beforehand that every subclass must have this timing property, then we should look up to __metaclass__ based solution.

So, the challenge is that when the classes are created, they should be immediately wrapped up by a timing method decorator. The solution requires _three_ steps:

+ Create a metaclass `TimeMeta` feeding class object to the class decorator method

+ Create a class decorator method `timeit` that makes use of `time_taken` decorator to debug class methods.

+ Create `time_taken` decorator that times the passed method by keeping track of _start time_ and _end time_.

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

Challenge: Time My Functions

Problem statement