Python Object Oriented Programming OOP Beginner to Pro

Python Object Oriented Programming OOP Beginner to Pro

What you’ll learn

Learn Python object-oriented programming from the ground up with in-depth lectures and practice activities
Work through 16 detailed project assignments to put your learning to practice
Write your own classes with customized behavior, representation, and relationships
Understand inheritance and multiple inheritance including best practices and the ideal use cases
Understand modern language constructs like dataclasses, enumerations, slots, and more
Master the Pythonic style of working with types, built-ins, and their derivatives
Get a deep understanding of the more difficult parts including descriptors, abstract base classes and metaprogramming
Create your own version of data structures with special behaviour, e.g. a list that sorts itself, or a dictionary that never raises KeyError
Work effectively with the exceptions and define your own separate exception hierarchies

Requirements

A computer (Windows/Mac/Linux). That’s all!
Prepare to write thousands of lines of Python code
No prior knowledge of python is required

Description

Welcome to the best resource online and the only one you need to learn and master object-oriented programming with modern python! There has never been a better time to learn python. It is consistently ranked in the top 3 most in-demand and most-loved programming languages in the world, with applications in machine learning, web development, data science, automation, game development, and much more. And its growth shows no signs of stopping. But while there are plenty of resources to learn the basics of python, it is quite difficult to move past those to the intermediate and advanced facets of the language. This course seeks to address that. Over more than 20 hours of detailed lectures, live coding, and guided projects we will unpack everything that python has to offer, starting from absolute scratch. We will master not only object-oriented python and how to use it, but in the process also gain an understanding of the python data model and the essence of writing pythonic code. Every five to ten lectures we will stop and practice what we have covered, as we work through a list of detailed requirements and convert that to an object-oriented solution using nothing by zero-dependencies, pure python. ––––– Structure & Curriculum –––––The curriculum is organized around three parts of increasing target proficiency.In the first, we will cover the essential foundations of working with classes in python, defining our own types, customizing them using dunders, exposing managed attributes through properties and effectively using inheritance.· Classes· Dunders· Properties· InheritanceHaving established that core foundation, in the next five sections, we will dive into more advanced topics that effective python developers rely on. These include modern features like dataclasses, enumerations and slots but also more established, pivotal constructs like descriptors and exceptions.· Slots· Dataclasses· Descriptors· Enumerations· ExceptionsThen in the final four sections we will take a look under the hood at how python recognizes and works with types. We will explore, practice and implement several patterns including duck typing, dynamic protocols and abstract base classes. Finally, we will look at the internal machinery that produces classes in python, as we turn our attention to class metaprogramming.· Dynamic Protocols· Abstract Base Classes· Multiple Inheritance· Class MetaprogrammingThis course is intended for anyone who is committed to mastering object-oriented programming with python, regardless of prior experience, which is why a full-length bonus introduction to the python programming language is included to get anyone up and running writing pythonic code in no time.I hope you commit to joining me in this journey as we take your python to the next level. See you inside!

Overview

Section 1: Introduction

Lecture 1 Introduction

Lecture 2 All Course Resources

Section 2: Classes

Lecture 3 Section Intro

Lecture 4 PEP8

Lecture 5 Our First Class

Lecture 6 Class State

Lecture 7 Methods And Behaviour

Lecture 8 Instance Attributes

Lecture 9 Alternatively: getattr() And setattr()

Lecture 10 Revisting self

Lecture 11 Skill Challenge #1

Lecture 12 Solution

Lecture 13 Class and Static Methods

Lecture 14 BONUS: An Alternative Syntax

Lecture 15 Dunder Dict

Lecture 16 Class vs Instance __dict__

Lecture 17 BONUS: Careful With Mutables

Lecture 18 Access Control

Lecture 19 Docstrings

Lecture 20 Skill Challenge #2

Lecture 21 Solution

Lecture 22 Quick Gotcha

Lecture 23 Section Resources

Section 3: Dunders

Lecture 24 Section Intro

Lecture 25 Let’s Add A __repr__

Lecture 26 __repr__ vs __str__

Lecture 27 __format__

Lecture 28 Object Equality

Lecture 29 BONUS: Non-Equality

Lecture 30 Hashing and Mutability

Lecture 31 Hashable Book

Lecture 32 BONUS: Hashing Gotcha

Lecture 33 Skill Challenge #3

Lecture 34 Solution

Lecture 35 Other Rich Comparisons

Lecture 36 A Better Way

Lecture 37 Truthiness

Lecture 38 BONUS: Truth Value Testing Via __len__

Lecture 39 Container Classes

Lecture 40 Pythonic Add

Lecture 41 The __getitem__ Magic

Lecture 42 Defining Our Own Magics

Lecture 43 Skill Challenge #4

Lecture 44 Solution

Lecture 45 Section Resources

Section 4: Properties

Lecture 46 Section Intro

Lecture 47 Loyal Customers

Lecture 48 Always Start Plain

Lecture 49 A Refactor

Lecture 50 Private And Mangled Attributes

Lecture 51 Breaking Changes

Lecture 52 Properties Live In The Class

Lecture 53 Skill Challenge #5

Lecture 54 Solution

Lecture 55 Decorator Syntax

Lecture 56 BONUS: Decorators Refresher

Lecture 57 Read or Write Only Properties

Lecture 58 Managed Attributes

Lecture 59 BONUS: Caching Average Review

Lecture 60 Deleting Properties

Lecture 61 Property Docstrings

Lecture 62 Skill Challenge #6

Lecture 63 Solution

Lecture 64 Section Resources

Section 5: Inheritance

Lecture 65 Section Intro

Lecture 66 Inheritance

Lecture 67 What Is Inheritance Good For?

Lecture 68 All Classes Inherit From object

Lecture 69 Method Resolution Order

Lecture 70 Subclass Overrides

Lecture 71 Better Parent Delegation: super()

Lecture 72 Subclass __init__

Lecture 73 Skill Challenge #7

Lecture 74 Solution

Lecture 75 Subclassing Properties

Lecture 76 Extending Built-ins

Lecture 77 Another Example

Lecture 78 Beware The Pitfalls

Lecture 79 Beyond Inheritance

Lecture 80 Skill Challenge #8

Lecture 81 Solution

Lecture 82 Section Resources

Section 6: Slots

Lecture 83 Section Intro

Lecture 84 Instance Data Storage Review

Lecture 85 Slots

Lecture 86 Class Residents

Lecture 87 BONUS: Demonstrating The Memory Advantage

Lecture 88 Inheriting Slots

Lecture 89 Something To Avoid

Lecture 90 Should We Always Use Slots?

Lecture 91 Skill Challenge #9

Lecture 92 Solution

Lecture 93 Section Resources

Section 7: Dataclasses

Lecture 94 Section Intro

Lecture 95 The Why

Lecture 96 An Alternative: namedtuple

Lecture 97 BONUS: A Quick Point On Immutability

Lecture 98 BONUS: Typed NamedTuple

Lecture 99 Dataclasses

Lecture 100 Batteries Included

Lecture 101 Type Hints

Lecture 102 Customizing Fields

Lecture 103 BONUS: Further Customization

Lecture 104 Immutability

Lecture 105 Inheritance

Lecture 106 Why Not Just Namedtuples?

Lecture 107 Skill Challenge #10

Lecture 108 Solution

Lecture 109 Section Resources

Section 8: Descriptors

Lecture 110 Section Intro

Lecture 111 Attribute Lookup Chain Review

Lecture 112 The Descriptor Protocol

Lecture 113 Using A Descriptor

Lecture 114 Descriptor Storage

Lecture 115 Even Better: Instance Storage

Lecture 116 Using __set_name__

Lecture 117 Tying Up Loose Ends

Lecture 118 Non-Data Descriptors

Lecture 119 Aren’t Properties Just Better?

Lecture 120 BONUS: Similar How?

Lecture 121 Skill Challenge #11

Lecture 122 Solution

Lecture 123 Refactored Solution

Lecture 124 Section Resources

Section 9: Enums

Lecture 125 Section Intro

Lecture 126 What’s The Point?

Lecture 127 Enumerations

Lecture 128 Members

Lecture 129 Aliases vs Masters

Lecture 130 Uniqueness

Lecture 131 BONUS: Functional Syntax

Lecture 132 Automatic Values

Lecture 133 Customizing Next Values

Lecture 134 Extensibility

Lecture 135 Flags

Lecture 136 Bitmasks

Lecture 137 BONUS: How Bitwise Works

Lecture 138 Skill Challenge #12

Lecture 139 Solution

Lecture 140 Section Resources

Section 10: Exceptions

Lecture 141 Section Intro

Lecture 142 The Exception Object

Lecture 143 Handling

Lecture 144 Raising

Lecture 145 EAFP

Lecture 146 What’s Up With SyntaxError?

Lecture 147 Exception Hierarchy

Lecture 148 The Else Clause

Lecture 149 Finally

Lecture 150 Nesting And Bundling

Lecture 151 Rolling Our Own

Lecture 152 Skill Challenge #13

Lecture 153 Solution

Lecture 154 Section Resources

Section 11: Dynamic Protocols

Lecture 155 Section Intro

Lecture 156 Python Is Dynamically Typed

Lecture 157 Duck Typing

Lecture 158 Protocols

Lecture 159 The Making Of A Sequence

Lecture 160 ZooFavorites

Lecture 161 Pythonic Slicing

Lecture 162 BONUS: From Iteration To Iterables And Iterators

Lecture 163 BONUS: The Iterator Protocol

Lecture 164 BONUS: Extreme Duck Typing

Lecture 165 Skill Challenge #14

Lecture 166 Solution

Lecture 167 Section Resources

Section 12: Abstract Base Classes

Lecture 168 Section Intro

Lecture 169 Duck Typing May Be Enough

Lecture 170 Type Checking Refresher

Lecture 171 Abstract Base Classes

Lecture 172 BONUS: When Should We Create Our Own?

Lecture 173 Standard Lib ABCs

Lecture 174 A Quick Look Under The Hood

Lecture 175 Skill Challenge #15

Lecture 176 Solution

Lecture 177 Refactored Solution

Lecture 178 Re-refactored Solution

Lecture 179 Section Resources

Section 13: Multiple Inheritance

Lecture 180 Section Intro

Lecture 181 It Makes Sense

Lecture 182 Sharing Behaviour

Lecture 183 Parent __init__()

Lecture 184 Revisiting super()

Lecture 185 Variadics

Lecture 186 The Diamond Problem

Lecture 187 What Drives __mro__?

Lecture 188 Worth It?

Lecture 189 Mixins

Lecture 190 Organizing Interfaces

Lecture 191 Skill Challenge #16

Lecture 192 Solution

Lecture 193 Section Resources

Section 14: Class Metaprogramming

Lecture 194 Section Intro

Lecture 195 What Is Meta?

Lecture 196 Classes Are Objects

Lecture 197 type() As Class Factory

Lecture 198 BONUS: More On Dynamic Class Creation

Lecture 199 Defining Our Own Metaclass

Lecture 200 Inside The Belly Of The Monster

Lecture 201 Exhibit A: Zero Instance Classes And Singletons

Lecture 202 Exhibit B: Enforcing Unique Method Names

Lecture 203 Deeper Magic Than 99%

Lecture 204 Section Resources

Section 15: Appendix A – A Brief Introduction To Python

Lecture 205 Welcome

Lecture 206 Data Types

Lecture 207 Arithmetic And Augmented Assignment Operators

Lecture 208 Ints And Floats

Lecture 209 Booleans And Comparison Operators

Lecture 210 Strings

Lecture 211 Methods

Lecture 212 Containers I – Lists

Lecture 213 Lists vs. Strings

Lecture 214 List Methods And Functions

Lecture 215 Containers II – Tuples

Lecture 216 Containers III – Sets

Lecture 217 Containers IV – Dictionaries

Lecture 218 Dictionary Keys And Values

Lecture 219 Membership Operators

Lecture 220 Controlling Flow – if, else, And elif

Lecture 221 Truth Value Of Non-booleans

Lecture 222 For Loops

Lecture 223 The range() Immutable Sequence

Lecture 224 While Loops

Lecture 225 Break And Continue

Lecture 226 Zipping Iterables

Lecture 227 List Comprehensions

Lecture 228 Defining Functions

Lecture 229 Function Arguments – Positional vs Keyword

Lecture 230 Lambdas

Lecture 231 Importing Modules

Everyone interested in learning and mastering object-oriented python from the ground up,Learners with some Python experience who want to take their skill to the next level,Python developers who want to gain a deeper understanding

Course Information:

Udemy | English | 26h 45m | 6.66 GB
Created by: Andy Bek

You Can See More Courses in the Developer >> Greetings from CourseDown.com