What is the best way to learn an object oriented programming language with framework, data structure and alogrithms? At first I will say, I known some basics Python and Haskell. For now I decided to follow my programming road with Python. I have chosen a few issues and their learning path, hence I would like to know if they will be a good way to get to know Python programming language better, with the implementation of algorithms including languages, with the implementation and knowledge of data structures and modules and frameworks. 

Also I would like to ask what should I add to my list or delete? Of course, the issues will be mixed up so that you do not learn only data structures all day long and maybe it is a good idea? Additionally, I would like to know if additional projects or exercises are needed in all situations? I know that some issues are very easy and after reading I am able to notice the problems, advantages, disadvantages or exemplary implementation that arise.

If I have mistaken the forum, I am sorry and I am asking for appropriate redirection.

So the list looks like:

Programming and some other derivatives


Object-oriented


Classes
Objects
Interfaces
Abstraction
Encapsulation
Polymorphism
Inheritance


Duck Typing

SOLID rules


one responsibility
open + closed
substitutions Liskov
segregation of interfaces
reversing dependencies

Tests


Unitary
Functional
Integration


Monkey Patching
REST


HATEOAS

PEP8
MOCKS
VirtualENV
Asynchrony
Python Idioms


Decorators
Gneratory
Mapping
Meta class

Any other things from Python


Mutable and immutable objects
__init__
__str__
iteration
self

MVC


MVT



Frameworks


flask
pandas
tornado
django (basics)


Patterns
ORM



Modules


NumPy


Database


NoSQL


MongoDB

SQL


MySQL



Additional items


Git
Docker


Project patterns


Observer
Builder
Facade
Factory
Singleton antisense


Data structures


Basics


Stack
Queue
List


One directional
Two-directional
With the sentry

Trees


Binary
Binary searches
BSP
AVL
T
B

Graphs



Algorithms


Operating principles


divide and conquer
greedily
dynamic
linear

Techniques


procedural
recursive
object-oriented

Sorting


Bubble
Insertion
Quick
Merge

Search


Linear
Binary

Graphs


Dijkstra
DFS
BFS
Kruskal
Prim

Data mining


C4.5
k-means
You certainly don't need a list longer than this one. If you do even half of this you will have learned enough to know pretty much what should be next. Having a complete list now gives you very little. 

What you really need is practice and feedback. For practice, find some significant problem and build a program to solve it. Use the best methodology you know about (including testing) and if it works, fine, otherwise look at some other methodologies. You can often find problems in books or online, but knowing that something is significant is harder for a self learner. 

But the biggest impediment for the self learner is getting adequate feedback. Just because something works isn't evidence that it is actually good or well structured. For feedback you need someone with more python knowledge than you have and who can comment on your code and even on your approach. That is one of the big advantages of taking regular courses. A teacher/professor can provide problems that are just hard enough to stretch your skills, but also give you the feedback on what you are doing and point to the next steps. 

But reading about all those things won't make a programmer out of you, nor will building a "complete" list. 

Write programs. Get feedback. There is no shortcut.