Book Image

Python 3 Object-Oriented Programming - Second Edition

By : Dusty Phillips
Book Image

Python 3 Object-Oriented Programming - Second Edition

By: Dusty Phillips

Overview of this book

Python 3 is more versatile and easier to use than ever. It runs on all major platforms in a huge array of use cases. Coding in Python minimizes development time and increases productivity in comparison to other languages. Clean, maintainable code is easy to both read and write using Python's clear, concise syntax. Object-oriented programming is a popular design paradigm in which data and behaviors are encapsulated in such a way that they can be manipulated together. Many modern programming languages utilize the powerful concepts behind object-oriented programming and Python is no exception. Starting with a detailed analysis of object-oriented analysis and design, you will use the Python programming language to clearly grasp key concepts from the object-oriented paradigm. This book fully explains classes, data encapsulation, inheritance, polymorphism, abstraction, and exceptions with an emphasis on when you can use each principle to develop well-designed software. You'll get an in-depth analysis of many common object-oriented design patterns that are more suitable to Python's unique style. This book will not just teach Python syntax, but will also build your confidence in how to program. You will also learn how to create maintainable applications by studying higher level design patterns. Following this, you'll learn the complexities of string and file manipulation, and how Python distinguishes between binary and textual data. Not one, but two very powerful automated testing systems will be introduced in the book. After you discover the joy of unit testing and just how easy it can be, you'll study higher level libraries such as database connectors and GUI toolkits and learn how they uniquely apply object-oriented principles. You'll learn how these principles will allow you to make greater use of key members of the Python eco-system such as Django and Kivy. This new edition includes all the topics that made Python 3 Object-oriented Programming an instant Packt classic. It's also packed with updated content to reflect recent changes in the core Python library and covers modern third-party packages that were not available on the Python 3 platform when the book was first published.  
Table of Contents (21 chapters)
Python 3 Object-oriented Programming Second Edition
Credits
About the Author
About the Reviewers
www.PacktPub.com
Introduction to the second edition
Preface
Index

Index

A

  • absolute imports
    • about / Absolute imports
  • abstract base classes (ABCs)
    • about / Abstract base classes
    • using / Using an abstract base class
    • creating / Creating an abstract base class
    • @classmethod / Demystifying the magic
  • abstract factory pattern
    • about / The abstract factory pattern
  • abstraction
    • about / Hiding details and creating the public interface
    • examples / Hiding details and creating the public interface
    • defining / Inheritance provides abstraction
  • abstract methods
    • about / Inheritance
  • access control
    • about / Who can access my data?
  • adapter pattern
    • about / The adapter pattern
    • Interface1 / The adapter pattern
    • Interface2 / The adapter pattern
    • Adapter class / The adapter pattern
  • aggregation
    • about / Composition
    • and composition, comparing / Composition
  • arguments
    • about / Behaviors are actions
  • assertion methods
    • about / Assertion methods
  • AsyncIO
    • about / AsyncIO
    • implementing / AsyncIO in action
    • future, reading / Reading an AsyncIO future
    • for networking / AsyncIO for networking
    • executors, using to wrap blocking code / Using executors to wrap blocking code
    • streams / Streams
    • executors / Executors
  • attribute
    • about / Data describes objects
  • attributes
    • specifying / Specifying attributes and behaviors

B

  • basic inheritance
    • about / Basic inheritance
    • built-ins, extending / Extending built-ins
    • overriding / Overriding and super
    • super function / Overriding and super
  • behaviors
    • about / Introducing object-oriented
    • specifying / Specifying attributes and behaviors
    • defining / Behaviors are actions
  • bottom-up design / Exercises
  • built-ins
    • extending / Extending built-ins

C

  • CamelCase notation / Creating Python classes
  • case study, object-oriented design
    • about / Case study
  • character classes / Matching a selection of characters
  • class
    • about / Objects and classes
  • classes
    • defining / Objects and classes
  • code coverage
    • about / How much testing is enough?
  • code coverage test
    • verifying / How much testing is enough?
  • command pattern
    • about / The command pattern
  • composite pattern
    • about / The composite pattern
  • composition
    • about / Composition
  • comprehensions
    • list comprehensions / List comprehensions
    • dictionary comprehension / Set and dictionary comprehensions
    • generator expressions / Generator expressions
  • concurrency
    • case study / Case study
  • constructor / Initializing the object
  • context manager
    • about / Placing it in context
  • coroutines
    • about / Coroutines
    • log parsing / Back to log parsing
    • closing / Closing coroutines and throwing exceptions
    • exception, raising / Closing coroutines and throwing exceptions
    • relationship, with generators / The relationship between coroutines, generators, and functions
    • relationship, with functions / The relationship between coroutines, generators, and functions
  • Counter object / Counter
  • coverage.py / How much testing is enough?

D

  • data
    • about / Introducing object-oriented
    • defining / Data describes objects
    • objects, defining / Data describes objects
  • data notation / Serializing web objects
  • decorator pattern
    • about / The decorator pattern
    • uses / The decorator pattern
    • Core / The decorator pattern
    • Interface / The decorator pattern
    • example / A decorator example
    • using, in Python / Decorators in Python
  • decorators
    • about / Decorators – another way to create properties
  • design patterns
    • about / Design patterns in brief
    • decorator pattern / The decorator pattern
    • observer pattern / The observer pattern
    • strategy pattern / The strategy pattern
    • state pattern / The state pattern
    • singleton pattern / The singleton pattern
    • template pattern / The template pattern
    • adapter pattern / The adapter pattern
    • facade pattern / The facade pattern
    • flyweight pattern / The flyweight pattern
    • command pattern / The command pattern
    • abstract factory pattern / The abstract factory pattern
    • composite pattern / The composite pattern
  • Dewey Decimal System (DDS)
    • about / Case study
  • dictionaries
    • about / Dictionaries
    • use cases / Dictionary use cases
    • defaultdict, using / Using defaultdict
    • Counter object / Counter
  • dictionary comprehension
    • about / Set and dictionary comprehensions
  • docstrings
    • about / Explaining yourself
    • using / Explaining yourself
  • dot notation / Adding attributes
  • duck typing
    • about / Inheritance provides abstraction

E

  • empty objects
    • about / Empty objects
  • encapsulation
    • about / Hiding details and creating the public interface
  • exceptions
    • raising / Raising exceptions, Raising an exception
    • effects / The effects of an exception
    • handling / Handling exceptions
    • hierarchy / The exception hierarchy
    • custom exceptions, defining / Defining our own exceptions
    • case study / Case study
  • expensive objects
    • imitating / Imitating expensive objects

F

  • facade pattern
    • about / The facade pattern
  • FIFO (First In First Out) queues
    • about / FIFO queues
  • file I/O
    • about / File I/O
  • flyweight pattern
    • about / The flyweight pattern
  • funcargs / A completely different way to set up variables
  • functions
    • about / Functions are objects too
    • using, as attributes / Using functions as attributes
    • callable objects / Callable objects
  • futures
    • about / Futures

G

  • generators
    • about / Generators
    • data, yielding from another iterable / Yield items from another iterable
  • global interpreter lock (GIL) / The global interpreter lock

H

  • hashable / Dictionaries

I

  • information hiding
    • defining / Hiding details and creating the public interface
    • about / Hiding details and creating the public interface
  • inheritance
    • about / Composition, Inheritance
    • case study / Case study
  • instance diagram
    • about / Composition
  • interfaces
    • about / Inheritance
  • International Standard Book Number (ISBN)
    • about / Case study
  • iterator pattern
    • case study / Case study
  • iterators
    • about / Iterators
    • iterator protocol / The iterator protocol

J

  • JavaScript Object Notation (JSON) / Serializing web objects

L

  • LIFO (Last In First Out) queues
    • about / LIFO queues
  • list comprehensions
    • about / List comprehensions
  • lists
    • about / Lists
    • sorting / Sorting lists

M

  • mailing list manager, case study
    • building / Case study
  • members
    • about / Data describes objects
  • method overloading
    • about / An alternative to method overloading
    • default arguments / Default arguments
    • variable argument lists / Variable argument lists
    • unpacking arguments / Unpacking arguments
  • methods
    • about / Behaviors are actions
  • module contents
    • organizing / Organizing module contents
  • modules
    • about / Modules and packages
    • example / Modules and packages
    • organizing / Organizing the modules
    • absolute imports / Absolute imports
    • relative imports / Relative imports
  • multiple inheritance
    • about / Multiple inheritance, Multiple inheritance
    • diamond problem / The diamond problem
    • sets of arguments / Different sets of arguments
  • multiprocessing
    • about / Multiprocessing
    • pools / Multiprocessing pools
    • queues / Queues
    • drawbacks / The problems with multiprocessing
  • mutable byte strings
    • about / Mutable byte strings

O

  • object
    • and class, comparing / Objects and classes
  • object-oriented
    • defining / Introducing object-oriented
  • Object-oriented analysis (OOA)
    • about / Introducing object-oriented
  • object-oriented design
    • analysis problems / Exercises
  • Object-oriented design (OOD)
    • about / Introducing object-oriented
  • object-oriented programming
    • examples / Inheritance
    • case study / Case study
  • Object-oriented programming (OOP)
    • about / Introducing object-oriented
  • object diagram
    • about / Composition
  • objects
    • defining / Objects and classes
    • about / Treat objects as objects
    • identifying / Treat objects as objects
    • managing / Manager objects
    • duplicate code, removing / Removing duplicate code
    • existing code, reusing / In practice
    • serializing / Serializing objects
    • pickles, customizing / Customizing pickles
    • web objects, serializing / Serializing web objects
  • observer pattern
    • about / The observer pattern
    • example / An observer example

P

  • package
    • about / Organizing the modules
  • parameters
    • about / Behaviors are actions
  • patterns matching, regular expression
    • about / Matching patterns
    • selection of characters, matching / Matching a selection of characters
    • characters, escaping / Escaping characters
    • multiple characters, matching / Matching multiple characters
    • patterns, grouping / Grouping patterns together
  • PEP 3101
    • URL / Making it look right
  • pick action
    • about / Behaviors are actions
  • pitfalls, threads
    • about / The many problems with threads
    • shared memory / Shared memory
    • global interpreter lock / The global interpreter lock
  • polymorphism
    • about / Inheritance provides abstraction, Polymorphism
  • priority queue
    • about / Priority queues
  • properties
    • about / Data describes objects
    • using, for adding behavior to class data / Adding behavior to class data with properties
    • using / Deciding when to use properties
  • property constructor / Properties in detail
  • property function / Properties in detail
  • public interface
    • creating / Hiding details and creating the public interface
  • py.test
    • about / Testing with py.test
    • testing with / Testing with py.test
    • setup / One way to do setup and cleanup
    • cleanup / One way to do setup and cleanup
    • variables, setting up / A completely different way to set up variables
    • tests, skipping with / Skipping tests with py.test
  • Python
    • about / Explaining yourself
  • Python built-in functions
    • about / Python built-in functions
    • len() function / The len() function
    • reversed() function / Reversed
    • enumerate function / Enumerate
  • Python classes
    • creating / Creating Python classes
    • attributes, adding / Adding attributes
    • implementing / Making it do something
    • arguments / More arguments
    • object, initializing / Initializing the object
  • Python data structures
    • empty objects / Empty objects
    • tuples / Tuples and named tuples
    • named tuples / Named tuples
    • dictionaries / Dictionaries
    • lists / Lists
    • sets / Sets
    • built-ins, extending / Extending built-ins
    • queues / Queues
    • case study / Case study

Q

  • queues
    • about / Queues
    • FIFO queues / FIFO queues
    • LIFO queues / LIFO queues
    • priority queues / Priority queues

R

  • regular expressions
    • about / Regular expressions
    • patterns, matching / Matching patterns
    • information, obtaining from / Getting information from regular expressions
    • repeated regular expressions, making efficient / Making repeated regular expressions efficient
    • case study / Case study
  • relative imports
    • about / Relative imports

S

  • self argument / Talking to yourself
  • sequence diagram
    • about / Case study
  • sets
    • about / Sets
  • simple command-line notebook application
    • building / Case study
  • singleton pattern
    • about / The singleton pattern
    • implementing / Singleton implementation
  • slots
    • about / Empty objects
  • stacks / LIFO queues
  • state pattern
    • about / The state pattern
    • example / A state example
    • versus, strategy pattern / State versus strategy
    • state transition as coroutines / State transition as coroutines
  • strategy pattern
    • about / The strategy pattern
    • User code / The strategy pattern
    • Abstraction interface / The strategy pattern
    • example / A strategy example
    • using, in Python / Strategy in Python
  • string formatting
    • about / String formatting
    • braces, escaping / Escaping braces
    • keyword arguments / Keyword arguments
    • container lookups / Container lookups
    • object lookups / Object lookups
  • string manipulation
    • about / String manipulation
  • strings
    • about / Strings, Strings are Unicode
    • bytes, converting to text / Converting bytes to text
    • text, converting to bytes / Converting text to bytes
    • mutable byte strings / Mutable byte strings
  • SyntaxError / Initializing the object

T

  • template pattern
    • about / The template pattern
    • example / A template example
  • test
    • need for / Why test?
  • test-driven development
    • about / Test-driven development
    • case study / Case study, Implementing it
  • third-party libraries
    • about / Third-party libraries
  • threads
    • about / Threads
    • pitfalls / The many problems with threads
    • thread overhead / Thread overhead
  • top-down design / Exercises
  • tuples
    • about / Tuples and named tuples
    • named tuples / Named tuples

U

  • UDP (User Datagram Protocol) / AsyncIO for networking
  • UML sequence diagram
    • about / Case study
  • Unified Modeling Language (UML)
    • about / Objects and classes
    • example / Objects and classes
  • unit tests
    • about / Unit testing
    • assertion methods / Assertion methods
    • boilerplate, reducing / Reducing boilerplate and cleaning up
    • organizing / Organizing and running tests
    • running / Organizing and running tests
    • broken tests, ignoring / Ignoring broken tests

V

  • value / Dictionaries
  • values
    • about / Behaviors are actions

W

  • web objects
    • serializing / Serializing web objects