3
$\begingroup$

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
Improve this question
$\endgroup$
3
  • $\begingroup$ I recommend learning modelling with UML (class diagrams and more, but especially class diagrams). $\endgroup$
    – deHaar
    Dec 18, 2018 at 8:52
  • $\begingroup$ I good way to learn object orientation is to learn Eiffel (language), first. It may seem like a diversion, but it will be quicker. You will learn OO properly, then you can learn how to apply it to any language. (and singleton is an anti-pattern, I have seen no valid use for it, except to wrap unprotected mono-static code. mono-static code is also an anti-pattern.). $\endgroup$
    – ctrl-alt-delor
    Dec 18, 2018 at 11:58
  • $\begingroup$ That is years worth of material. I also seriously doubt that you'll use more than a fraction of it in your professional career (which fraction will depend on the career). $\endgroup$
    – Jared Smith
    Feb 18, 2019 at 18:41

2 Answers 2

Reset to default
7
$\begingroup$

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.

Improve this answer
$\endgroup$
2
  • $\begingroup$ For feedback, with working code that might be improved for performance, clarity, etc., there is Code Review where feedback might be available. $\endgroup$
    – Gypsy Spellweaver
    Dec 10, 2018 at 22:14
  • $\begingroup$ I agree this list is far to long. This is too much planning. When I park my car, I never know where it is. However I always know which way to turn at each junction. I take the shortest (or nearly), path. I don't need to plan the whole path. Same is true of programming, or learning. When you learn new things, the plan will have to change, so don't over plan it. $\endgroup$
    – ctrl-alt-delor
    Dec 18, 2018 at 11:55
5
$\begingroup$

Your list of items is very complete and would fill a good part of a Bachelor's degree curriculum. One thing to not overlook is that some of the aspects you highlight make little sense in the context of Python.

For instance, interfaces (as in Java Interfaces) express the behavior of classes that implements them, and can simulate multiple-inheritance. In Python, you have some kind of abstract classes and multiple-inheritance, which allows you to have the same results, but work really differently.

Likewise, the notion of type polymorphism (as in parametric polymorphism or Java/C# generics) is precisely that a function/method cannot inspect a parametric argument. In Python, function arguments are not typed so all this is moot. You can pass any argument to any function and it may or may not fail depending on what the function does.

This is not a critic of Python, but rather a remark that for some concepts, most of the teaching material that you will find will use another language (where the concepts makes more sense). Trying to shoehorn them in Python may result in non-idiomatic code that is both hard to read and does not fully illustrate the concept you study and its benefits.

Improve this answer
$\endgroup$
2
  • 1
    $\begingroup$ Actually, objects in python have types. Variables don't. It is an important distinction. The type of an object is set at creation and never changes. A variable can refer to any object independent of the type of the object. $\endgroup$
    – Buffy
    Dec 11, 2018 at 13:57
  • $\begingroup$ @Buffy point taken. That was a shortcut to say that since function parameters are not typed, python is not the ideal language to study parametric polymorphism. $\endgroup$
    – Kim Nguyễn
    Dec 11, 2018 at 14:08

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge that you have read and understand our privacy policy and code of conduct.

Not the answer you're looking for? Browse other questions tagged or ask your own question.