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

class Fibonacci:
    def __init__(self, n):
        self.limit = n
        self.count = 1
        self.a = 0
        self.b = 1
    
    def __iter__(self):
        return self
    
    def __next__(self):
        if self.count <= self.limit:    # Controlled iterations
            x = self.a
            self.a, self.b = self.b, self.a +self.b # Adding preceding values
            self.count += 1
            return x
        else:
            raise StopIteration

fib = Fibonacci(7)
iterator = iter(fib)

for x in iterator:
  print(x)

# Explanation
For calculating the Fibonacci sequence, we need _two_ variables to maintain the track as every number is the sum of the preceding two numbers: $F_{i} = F_{i-1} + F_{i-2}$

As required by the problem statement, the iterator `Fibonacci` has _three_ methods:
+ `__init__()` method
+ `__iter__()` method
+ `__next__()` method

Let's look at each of them one by one.

## The `__init__()` method
Here, we set an instance `limit` that defines the _maximum_ number of iterations, and another instance `count` to track the number of iterations completed successfully. 
Most importantly, to calculate sequence, we need _two_ separate variables. So, we create two instances `a` and `b`. We set `a` as __0__ and `b` as __1__, the first two Fibonacci numbers.

## The `__iter__()` method

This method returns nothing but the _iterator_ object.

## The `__next__()` method
This method contains the implementation of the algorithm. Look at __line 12__. We apply a condition (`self.count <= self.limit`) that controls when to stop the loop. Then comes the important part, i.e., calculating the next number in the sequence. Let's break down the task into a few steps:
+ In every iteration, we have to return the number stored in `a`. We'll create a dummy variable and set it with the value of `a`.
+ The instance `a` will be equal to `b`, and `b` will be equal to the sum of `b` and `a`.
+ We'll increment `count` by __1__ and return the value stored in the dummy variable in the first step.

All these steps are performed if the condition at __line 12__ is true. If it is not, then we raise an exception `StopIteration`.

Now, look at __line 20__. We create an object of `Fibonacci` with `n` as __7__. Its `iterator` is then passed in the loop to generate the sequence: __0, 1, 1, 2, 3, 5, 8__.

---

The solution to the 'Create a Fibonacci Iterator' challenge.

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

Solution Review: Create a Fibonacci Iterator

Explanation