Python Object-Oriented Programming: Build robust and maintainable object-oriented Python applications and libraries, 4th Edition Paperback – 2 July 2021

Frankly, I'm just giving up on this after much wading. This seems to suffer from the same issues as other Pakt programming books I have read. In trying to cater for the complete novice programmer, the experienced programmer in other languages coming fresh to Python, and the intermediate Python programmer looking to go deeper into Python's object-oriented idioms, it manages to do none of these things particularly well. It also attempts to be a sort of idiot's guide to object-oriented patterns and doesn't do that very well either. Trivial points are belaboured exhaustively while subtleties are glossed so fast you could miss them. I'm saying this as someone who started the book a second time after completing David Beasley's transparently clear and concise 'Python Distilled' in the hope of having a better grounding to carry me through the infelicities of this book, but it didn't. So, at second reading, page 543, I am throwing in the towel, and getting on with the infinitely more informative 'Fluent Python', O'Reilly's fully up to date meta-tome by the estimable Luciano Romalho. It's a darn shame because I imagine the authors are formidable programmers, but they don't have the knack of putting themselves in their audience's shoes, or even just running their text by a suitable beginner. I won't be buying Pakt titles again.

Both Lott's and Dusty's previous books have been great but this 4th Edition I found lacked the same attention to detail. The examples are messy with unnecessary type hints which add little and are entirely optional so why add them? OK to have them to explain, but not everywhere.The books tries to cover far too much material and a lot of it is not in-depth enough, the earlier editions went into more detail.Also disappointing is to find the book itself is "printed by Amazon", it feels like it's been photocopied with poor quality paper and for some reason white on black for code examples which make the whole page layout uneasy on the eye and really shows how poor the priting is. I returned my copy as it's not worth the money, not for the content or the poor print and paper quality. Sorry!

Like all books by Steven F. Lott, this book is no exception. I read all books by Steven, and I always learn something from them. Besides teaching how to write OOP and use it, this book explains how to write OOP code using modern data types like NamedTuple, TypedDict, tuples, etc.As always, I learned excellent tips and techniques on how to write nice tests. There are also very interesting chapters on Concurrency and Design Patterns.My only complaint is the type of examples provided in this book. Examples are complicated, and they are based on machine learning data, sailing data, etc. So to understand an example, sometimes you need to understand the domain knowledge of the example. I wish examples were simpler to get a concept and then maybe provide more complex examples.Steven is not biased to OOP in this book, but he also explains the difference between OOP and functional programming and teaches where OOP would be the best fit.In any way, it's an excellent book, and I learned a lot from it, and I use it as a reference if I need to find an answer to my questions.

Dear Packt,I have found an awesome content inside the book. But the quality of the binding I received from the publisher is unacceptable. Its not the first time, i encountered the issue.Pl don’t spoil the journey of reading awesome content just because of your poor quality of presentation.BR,Matthew

Per imparare a muoversi su oop in python, un libro intuitivoLo consiglio

Para quem não conhece POO em PYTHON, aprende ao ler/consultar o livro. Deveria ter mais exemplos!Como não gosto de ver filmes online, está a ser óptimo.

Disclaimer: I'm no expert in OOP, and I decided to purchase the book for self-improvement. I have mostly experience in functional programming from a C/C++ standpoint. This is only a partial review for the 4th edition, since I'm currently skimming from one chapter to the other, mostly for comparison with the previous editions (e.g. 2nd). As I'm writing, I have the 2nd and 4th edition. I don't know the authors.Good points about the 4th edition:1)introductory first 5 chapters are well crafted. Some Case studies have been removed (e.g. Notebook, Real Estate) and others have been added, which, in case you have both editions, can be interesting to compare / go through.2)Compared to the previous editions, some sections have been expanded / added, like an entirely new chapter on Abstract Base Classes & Operator Overloading3) some explanations are quite clearNegative points about the 4th edition:1) an updated GIT repo for the 4th edition would have been helpful (e.g. compare it with Aurelien Geron's Hands-on ML book). I can only find the 2nd and 3rd edition for Packt on Github.2) some sections (e.g. about do's and don'ts) are really verbose, and it would have helped to back up some statements with some code to understand what truly happens if something goes wrong.3) some examples don't seem to work out of the box.As I'm reading the Chapter on Common Design Patterns ( Ch11), in particular the section on decorating a socket, the try statement in dice_response() (page 466) returns a variable belonging to a dice object ( dice.dice_roller(request) ), while there are no hints about a Dice class in the entire paragraph about the Decorator Pattern. A Dice class is introduced in Chapter 11 only from page 488, in the Command Pattern.This section could have been written in a better way, in my opinion. After all, the section on Design Patterns (DP) is what makes OOP more interesting.Update: I was comparing the Decorator Pattern section with the implementation on the previous edition, and in this case, the code runs smoothly. For this reason, probably it would be better to read first the Design Pattern Section on the previous editions, and only afterwards to go through the 4th edition.I have to go through the remaining sections, but I'll consider backing up with some other references like :1) Luciano Ramahlo's Fluent Python (2nd edition)2) Practical Python Design Patterns, by Wessel Badenhorst3) Python Programming With Design Patterns, by James Cooper (from IBM, sharing same floor of John Vlissides from the Gang of Four)