Object Oriented Programming with Python 3

Explore inheritance and composition in Python to build extensible object oriented programs, using is-a and has-a relationships, with an employee management system including payroll and performance management.

Identify is-a inheritance by recognizing common attributes and overridden work methods, using a base class like employee and noting where multiple inheritance applies for roles like waiters.

Explain composition as a has-a relationship using a car and its engine. A composite car accesses engine attributes, while the engine cannot access car attributes, unlike inheritance.

Explore Python inheritance by contrasting default object inheritance with explicit base class usage and demonstrate a custom exception that inherits from Exception and uses super to pass a message.

Define interfaces as a description of an object's attributes and methods in Python, using payroll management to show how different employee types implement a common calculate payroll method through inheritance.

Explore implementing interfaces in Python through a payroll management system demo, building classes such as employee, salary employee, part time employee, and commission employee to compute payroll.

Extend the payroll system to an employee management system by adding a worker interface and four roles—manager, developer, salesperson, and company worker—mapped to salary, commission, and part-time payroll.

Transform a payroll management system into an employee management system by modularizing employees into separate classes—manager, developer, salesperson, and worker—under the I worker interface and track employee performance.

Covers the problems with multiple inheritance in Python, including constructor argument mismatches for a consultant, and shows that changing base class order can resolve the errors.

Explore how method resolution order governs the search path in Python, addressing the diamond problem in multiple inheritance and guiding re-architecting class hierarchies for robust design.

Explore the diamond problem in multiple inheritance and redesign an employee management system with payroll and job role interfaces to avoid conflicts.

Demonstrates practical handling of the diamond problem in Python's multiple inheritance by designing distinct role classes and payroll policies, then integrating them into employee classes.

Develop object oriented programming concepts by building and extending an application, preserving client integrity, then adopt solid programming principles to improve flexibility and design, preparing a redesign with best practices.

Explore solid design principles for object oriented programming, including the single responsibility principle, open closed principle, Liskov substitution principle, interface segregation principle, and dependency inversion principle, with demos in Python.

Learn the single responsibility principle, where a module has one reason to change, and see how separating responsibilities into dedicated classes (registration, logger, email) improves maintainability and testability.

Demonstrate the single responsibility principle with a Python demo that separates concerns: register user details to SQLite, send an email, and log errors, using a facade wrapper.

apply the open closed principle to extend software without modifying existing code, keeping it open for extension but closed for modifications, using inheritance or dependency injection, and abstract loggers.

Explore the open closed principle in Python by implementing a logger that writes errors to a text file and a SQLite database, and extend with a cloud logger via subclassing.

Explore the Liskov substitution principle (LSP) and its role in safe inheritance, showing why subtypes must substitute base types, illustrated by the rectangle versus square example.

Explore the limitations of the Liskov substitution principle in inheritance through a Python demo with rectangle and square, showing how width and height synchronization reveals is-a relationship pitfalls.

Apply the Liskov substitution principle by encapsulating behavior and using tell don't ask; explore shape hierarchies with rectangle, square, and Python's duck typing.

Explains the interface segregation principle, showing how to split fat interfaces into small cohesive ones so clients aren’t forced to implement unused methods, illustrated with Xerox printing and scanning scenarios.

Demonstrate the interface segregation principle by implementing separate interfaces for print, fax, and duplex tasks and composing them across basic, intermediate, and advanced printers.

Understand the dependency inversion principle: high and low level modules depend on abstractions, not details, and use constructor injection to avoid tight coupling with dependency injection.

Demonstrate dependency inversion by injecting authentication implementations via abstractions, using a service.json config to swap fake and db services without tight coupling.

Explore applying solid design principles in object oriented programming with Python through a practical employee management system case study.