Szczegóły ebooka

Python: Journey from Novice to Expert. Journey from Novice to Expert

Python: Journey from Novice to Expert. Journey from Novice to Expert

Fabrizio Romano, Dusty Phillips, Rick van Hattem

Ebook
Python is a dynamic and powerful programming language, having its application in a wide range of domains. It has an easy-to-use, simple syntax, and a powerful library, which includes hundreds of modules to provide routines for a wide range of applications, thus making it a popular language among programing enthusiasts.This course will take you on a journey from basic programming practices to high-end tools and techniques giving you an edge over your peers. It follows an interesting learning path, divided into three modules. As you complete each one, you’ll have gained key skills and get ready for the material in the next module.The first module will begin with exploring all the essentials of Python programming in an easy-to-understand way. This will lay a good foundation for those who are interested in digging deeper. It has a practical and example-oriented approach through which both the introductory and the advanced topics are explained. Starting with the fundamentals of programming and Python, it ends by exploring topics, like GUIs, web apps, and data science.In the second module you will learn about object oriented programming techniques in Python. Starting with a detailed analysis of object-oriented technique and design, you will use the Python programming language to clearly grasp key concepts from the object-oriented paradigm. This module 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.With a good foundation of Python you will move onto the third module which is a comprehensive tutorial covering advanced features of the Python language. Start by creating a project-specific environment using venv. This will introduce you to various Pythonic syntax and common pitfalls before moving onto functional features and advanced concepts, thereby gaining an expert level knowledge in programming and teaching how to script highest quality Python programs.
  • Python: Journey from Novice to Expert
    • Table of Contents
    • Python: Journey from Novice to Expert
    • Python: Journey from Novice to Expert
    • Credits
    • Preface
      • What this learning path covers
      • What you need for this learning path
      • Who this learning path is for
      • Reader feedback
      • Customer support
        • Downloading the example code
        • Errata
        • Piracy
        • Questions
    • 1. Module 1
      • 1. Introduction and First Steps Take a Deep Breath
        • A proper introduction
        • Enter the Python
        • About Python
          • Portability
          • Coherence
          • Developer productivity
          • An extensive library
          • Software quality
          • Software integration
          • Satisfaction and enjoyment
        • What are the drawbacks?
        • Who is using Python today?
        • Setting up the environment
          • Python 2 versus Python 3 the great debate
        • Installing Python
          • Setting up the Python interpreter
          • About virtualenv
          • Your first virtual environment
          • Your friend, the console
        • How you can run a Python program
          • Running Python scripts
          • Running the Python interactive shell
          • Running Python as a service
          • Running Python as a GUI application
        • How is Python code organized
          • How do we use modules and packages
        • Pythons execution model
          • Names and namespaces
          • Scopes
          • Object and classes
        • Guidelines on how to write good code
        • The Python culture
        • A note on the IDEs
        • Summary
      • 2. Built-in Data Types
        • Everything is an object
        • Mutable or immutable? That is the question
        • Numbers
          • Integers
          • Booleans
          • Reals
          • Complex numbers
          • Fractions and decimals
        • Immutable sequences
          • Strings and bytes
            • Encoding and decoding strings
            • Indexing and slicing strings
          • Tuples
        • Mutable sequences
          • Lists
          • Byte arrays
        • Set types
        • Mapping types dictionaries
        • The collections module
          • Named tuples
          • Defaultdict
          • ChainMap
        • Final considerations
          • Small values caching
          • How to choose data structures
          • About indexing and slicing
          • About the names
        • Summary
      • 3. Iterating and Making Decisions
        • Conditional programming
          • A specialized else: elif
          • The ternary operator
        • Looping
          • The for loop
            • Iterating over a range
            • Iterating over a sequence
          • Iterators and iterables
          • Iterating over multiple sequences
          • The while loop
          • The break and continue statements
          • A special else clause
        • Putting this all together
          • Example 1 a prime generator
          • Example 2 applying discounts
        • A quick peek at the itertools module
          • Infinite iterators
          • Iterators terminating on the shortest input sequence
          • Combinatoric generators
        • Summary
      • 4. Functions, the Building Blocks of Code
        • Why use functions?
          • Reduce code duplication
          • Splitting a complex task
          • Hide implementation details
          • Improve readability
          • Improve traceability
        • Scopes and name resolution
          • The global and nonlocal statements
        • Input parameters
          • Argument passing
          • Assignment to argument names don't affect the caller
          • Changing a mutable affects the caller
          • How to specify input parameters
            • Positional arguments
            • Keyword arguments and default values
            • Variable positional arguments
            • Variable keyword arguments
            • Keyword-only arguments
            • Combining input parameters
            • Avoid the trap! Mutable defaults
        • Return values
          • Returning multiple values
        • A few useful tips
        • Recursive functions
        • Anonymous functions
        • Function attributes
        • Built-in functions
        • One final example
        • Documenting your code
        • Importing objects
          • Relative imports
        • Summary
      • 5. Saving Time and Memory
        • map, zip, and filter
          • map
          • zip
          • filter
        • Comprehensions
          • Nested comprehensions
          • Filtering a comprehension
          • dict comprehensions
          • set comprehensions
        • Generators
          • Generator functions
          • Going beyond next
          • The yield from expression
          • Generator expressions
        • Some performance considerations
        • Don't overdo comprehensions and generators
        • Name localization
        • Generation behavior in built-ins
        • One last example
        • Summary
      • 6. Advanced Concepts OOP, Decorators, and Iterators
        • Decorators
          • A decorator factory
        • Object-oriented programming
          • The simplest Python class
          • Class and object namespaces
          • Attribute shadowing
          • I, me, and myself using the self variable
          • Initializing an instance
          • OOP is about code reuse
            • Inheritance and composition
          • Accessing a base class
          • Multiple inheritance
            • Method resolution order
          • Static and class methods
            • Static methods
            • Class methods
          • Private methods and name mangling
          • The property decorator
          • Operator overloading
          • Polymorphism a brief overview
        • Writing a custom iterator
        • Summary
      • 7. Testing, Profiling, and Dealing with Exceptions
        • Testing your application
          • The anatomy of a test
          • Testing guidelines
          • Unit testing
            • Writing a unit test
            • Mock objects and patching
            • Assertions
            • A classic unit test example
            • Making a test fail
            • Interface testing
            • Comparing tests with and without mocks
            • Boundaries and granularity
            • A more interesting example
        • Test-driven development
        • Exceptions
        • Profiling Python
          • When to profile?
        • Summary
      • 8. The Edges GUIs and Scripts
        • First approach scripting
          • The imports
          • Parsing arguments
          • The business logic
        • Second approach a GUI application
          • The imports
          • The layout logic
          • The business logic
            • Fetching the web page
            • Saving the images
            • Alerting the user
          • How to improve the application?
        • Where do we go from here?
          • The tkinter.tix module
          • The turtle module
          • wxPython, PyQt, and PyGTK
          • The principle of least astonishment
          • Threading considerations
        • Summary
      • 9. Data Science
        • IPython and Jupyter notebook
        • Dealing with data
          • Setting up the notebook
          • Preparing the data
          • Cleaning the data
          • Creating the DataFrame
            • Unpacking the campaign name
            • Unpacking the user data
            • Cleaning everything up
          • Saving the DataFrame to a file
          • Visualizing the results
        • Where do we go from here?
        • Summary
      • 10. Web Development Done Right
        • What is the Web?
        • How does the Web work?
        • The Django web framework
          • Django design philosophy
            • The model layer
            • The view layer
            • The template layer
          • The Django URL dispatcher
            • Regular expressions
        • A regex website
          • Setting up Django
            • Starting the project
            • Creating users
          • Adding the Entry model
          • Customizing the admin panel
          • Creating the form
          • Writing the views
            • The home view
            • The entry list view
            • The form view
          • Tying up URLs and views
          • Writing the templates
        • The future of web development
          • Writing a Flask view
          • Building a JSON quote server in Falcon
        • Summary
      • 11. Debugging and Troubleshooting
        • Debugging techniques
          • Debugging with print
          • Debugging with a custom function
          • Inspecting the traceback
          • Using the Python debugger
          • Inspecting log files
          • Other techniques
            • Profiling
            • Assertions
          • Where to find information
        • Troubleshooting guidelines
          • Using console editors
          • Where to inspect
          • Using tests to debug
          • Monitoring
        • Summary
      • 12. Summing Up A Complete Example
        • The challenge
        • Our implementation
        • Implementing the Django interface
          • The setup
          • The model layer
          • A simple form
          • The view layer
            • Imports and home view
            • Listing all records
            • Creating records
            • Updating records
            • Deleting records
          • Setting up the URLs
          • The template layer
            • Home and footer templates
            • Listing all records
            • Creating and editing records
            • Talking to the API
            • Deleting records
        • Implementing the Falcon API
          • The main application
          • Writing the helpers
            • Coding the password validator
            • Coding the password generator
          • Writing the handlers
            • Coding the password validator handler
            • Coding the password generator handler
          • Running the API
          • Testing the API
            • Testing the helpers
            • Testing the handlers
        • Where do you go from here?
        • Summary
    • 2. Module 2
      • 1. Object-oriented Design
        • Introducing object-oriented
        • Objects and classes
        • Specifying attributes and behaviors
          • Data describes objects
          • Behaviors are actions
        • Hiding details and creating the public interface
        • Composition
        • Inheritance
          • Inheritance provides abstraction
          • Multiple inheritance
        • Case study
        • Exercises
        • Summary
      • 2. Objects in Python
        • Creating Python classes
          • Adding attributes
          • Making it do something
            • Talking to yourself
            • More arguments
          • Initializing the object
          • Explaining yourself
        • Modules and packages
          • Organizing the modules
            • Absolute imports
            • Relative imports
        • Organizing module contents
        • Who can access my data?
        • Third-party libraries
        • Case study
        • Exercises
        • Summary
      • 3. When Objects Are Alike
        • Basic inheritance
          • Extending built-ins
          • Overriding and super
        • Multiple inheritance
          • The diamond problem
          • Different sets of arguments
        • Polymorphism
        • Abstract base classes
          • Using an abstract base class
          • Creating an abstract base class
          • Demystifying the magic
        • Case study
        • Exercises
        • Summary
      • 4. Expecting the Unexpected
        • Raising exceptions
          • Raising an exception
          • The effects of an exception
          • Handling exceptions
          • The exception hierarchy
          • Defining our own exceptions
        • Case study
        • Exercises
        • Summary
      • 5. When to Use Object-oriented Programming
        • Treat objects as objects
        • Adding behavior to class data with properties
          • Properties in detail
          • Decorators another way to create properties
          • Deciding when to use properties
        • Manager objects
          • Removing duplicate code
          • In practice
        • Case study
        • Exercises
        • Summary
      • 6. Python Data Structures
        • Empty objects
        • Tuples and named tuples
          • Named tuples
        • Dictionaries
          • Dictionary use cases
          • Using defaultdict
            • Counter
        • Lists
          • Sorting lists
        • Sets
        • Extending built-ins
        • Queues
          • FIFO queues
          • LIFO queues
          • Priority queues
        • Case study
        • Exercises
        • Summary
      • 7. Python Object-oriented Shortcuts
        • Python built-in functions
          • The len() function
          • Reversed
          • Enumerate
          • File I/O
          • Placing it in context
        • An alternative to method overloading
          • Default arguments
          • Variable argument lists
          • Unpacking arguments
        • Functions are objects too
          • Using functions as attributes
          • Callable objects
        • Case study
        • Exercises
        • Summary
      • 8. Strings and Serialization
        • Strings
          • String manipulation
          • String formatting
            • Escaping braces
            • Keyword arguments
            • Container lookups
            • Object lookups
            • Making it look right
          • Strings are Unicode
            • Converting bytes to text
            • Converting text to bytes
          • Mutable byte strings
        • Regular expressions
          • Matching patterns
            • Matching a selection of characters
            • Escaping characters
            • Matching multiple characters
            • Grouping patterns together
          • Getting information from regular expressions
            • Making repeated regular expressions efficient
        • Serializing objects
          • Customizing pickles
          • Serializing web objects
        • Case study
        • Exercises
        • Summary
      • 9. The Iterator Pattern
        • Design patterns in brief
        • Iterators
          • The iterator protocol
        • Comprehensions
          • List comprehensions
          • Set and dictionary comprehensions
          • Generator expressions
        • Generators
          • Yield items from another iterable
        • Coroutines
          • Back to log parsing
          • Closing coroutines and throwing exceptions
          • The relationship between coroutines, generators, and functions
        • Case study
        • Exercises
        • Summary
      • 10. Python Design Patterns I
        • The decorator pattern
          • A decorator example
          • Decorators in Python
        • The observer pattern
          • An observer example
        • The strategy pattern
          • A strategy example
          • Strategy in Python
        • The state pattern
          • A state example
          • State versus strategy
          • State transition as coroutines
        • The singleton pattern
          • Singleton implementation
        • The template pattern
          • A template example
        • Exercises
        • Summary
      • 11. Python Design Patterns II
        • The adapter pattern
        • The facade pattern
        • The flyweight pattern
        • The command pattern
        • The abstract factory pattern
        • The composite pattern
        • Exercises
        • Summary
      • 12. Testing Object-oriented Programs
        • Why test?
          • Test-driven development
        • Unit testing
          • Assertion methods
          • Reducing boilerplate and cleaning up
          • Organizing and running tests
          • Ignoring broken tests
        • Testing with py.test
          • One way to do setup and cleanup
          • A completely different way to set up variables
          • Skipping tests with py.test
        • Imitating expensive objects
        • How much testing is enough?
        • Case study
          • Implementing it
        • Exercises
        • Summary
      • 13. Concurrency
        • Threads
          • The many problems with threads
            • Shared memory
            • The global interpreter lock
          • Thread overhead
        • Multiprocessing
          • Multiprocessing pools
          • Queues
          • The problems with multiprocessing
        • Futures
        • AsyncIO
          • AsyncIO in action
          • Reading an AsyncIO future
          • AsyncIO for networking
          • Using executors to wrap blocking code
          • Streams
            • Executors
        • Case study
        • Exercises
        • Summary
    • 3. Module 3
      • 1. Getting Started One Environment per Project
        • Creating a virtual Python environment using venv
          • Creating your first venv
          • venv arguments
          • Differences between virtualenv and venv
        • Bootstrapping pip using ensurepip
          • ensurepip usage
          • Manual pip install
        • Installing C/C++ packages
          • Debian and Ubuntu
          • Red Hat, CentOS, and Fedora
          • OS X
          • Windows
        • Summary
      • 2. Pythonic Syntax, Common Pitfalls, and Style Guide
        • Code style or what is Pythonic code?
          • Formatting strings printf-style or str.format?
          • PEP20, the Zen of Python
            • Beautiful is better than ugly
            • Explicit is better than implicit
            • Simple is better than complex
            • Flat is better than nested
            • Sparse is better than dense
            • Readability counts
            • Practicality beats purity
            • Errors should never pass silently
            • In the face of ambiguity, refuse the temptation to guess
            • One obvious way to do it
            • Now is better than never
            • Hard to explain, easy to explain
            • Namespaces are one honking great idea
            • Conclusion
          • Explaining PEP8
            • Duck typing
            • Differences between value and identity comparisons
            • Loops
            • Maximum line length
          • Verifying code quality, pep8, pyflakes, and more
            • flake8
              • Pep8
              • pyflakes
              • McCabe
              • flake8
            • Pylint
        • Common pitfalls
          • Scope matters!
            • Function arguments
            • Class properties
            • Modifying variables in the global scope
          • Overwriting and/or creating extra built-ins
          • Modifying while iterating
          • Catching exceptions differences between Python 2 and 3
          • Late binding be careful with closures
          • Circular imports
          • Import collisions
        • Summary
      • 3. Containers and Collections Storing Data the Right Way
        • Time complexity the big O notation
        • Core collections
          • list a mutable list of items
          • dict unsorted but a fast map of items
          • set like a dict without values
          • tuple the immutable list
        • Advanced collections
          • ChainMap the list of dictionaries
          • counter keeping track of the most occurring elements
          • deque the double ended queue
          • defaultdict dictionary with a default value
          • namedtuple tuples with field names
          • enum a group of constants
          • OrderedDict a dictionary where the insertion order matters
          • heapq the ordered list
          • bisect the sorted list
        • Summary
      • 4. Functional Programming Readability Versus Brevity
        • Functional programming
        • list comprehensions
        • dict comprehensions
        • set comprehensions
        • lambda functions
          • The Y combinator
        • functools
          • partial no need to repeat all arguments every time
          • reduce combining pairs into a single result
            • Implementing a factorial function
            • Processing trees
        • itertools
          • accumulate reduce with intermediate results
          • chain combining multiple results
          • combinations combinatorics in Python
          • permutations combinations where the order matters
          • compress selecting items using a list of Booleans
          • dropwhile/takewhile selecting items using a function
          • count infinite range with decimal steps
          • groupby grouping your sorted iterable
          • islice slicing any iterable
        • Summary
      • 5. Decorators Enabling Code Reuse by Decorating
        • Decorating functions
          • Why functools.wraps is important
          • How are decorators useful?
          • Memoization using decorators
          • Decorators with (optional) arguments
          • Creating decorators using classes
        • Decorating class functions
          • Skipping the instance classmethod and staticmethod
          • Properties smart descriptor usage
        • Decorating classes
          • Singletons classes with a single instance
          • Total ordering sortable classes the easy way
        • Useful decorators
          • Single dispatch polymorphism in Python
          • Contextmanager, with statements made easy
          • Validation, type checks, and conversions
          • Useless warnings how to ignore them
        • Summary
      • 6. Generators and Coroutines Infinity, One Step at a Time
        • What are generators?
          • Advantages and disadvantages of generators
          • Pipelines an effective use of generators
          • tee using an output multiple times
          • Generating from generators
          • Context managers
        • Coroutines
          • A basic example
          • Priming
          • Closing and throwing exceptions
          • Bidirectional pipelines
          • Using the state
        • Summary
      • 7. Async IO Multithreading without Threads
        • Introducing the asyncio library
          • The async and await statements
            • Python 3.4
            • Python 3.5
            • Choosing between the 3.4 and 3.5 syntax
          • A simple example of single-threaded parallel processing
          • Concepts of asyncio
            • Futures and tasks
            • Event loops
              • Event loop implementations
              • Event loop policies
              • Event loop usage
            • Processes
          • Asynchronous servers and clients
            • Basic echo server
        • Summary
      • 8. Metaclasses Making Classes (Not Instances) Smarter
        • Dynamically creating classes
          • A basic metaclass
          • Arguments to metaclasses
          • Accessing metaclass attributes through classes
        • Abstract classes using collections.abc
          • Internal workings of the abstract classes
          • Custom type checks
          • Using abc.ABC before Python 3.4
        • Automatically registering a plugin system
          • Importing plugins on-demand
          • Importing plugins through configuration
          • Importing plugins through the file system
        • Order of operations when instantiating classes
          • Finding the metaclass
          • Preparing the namespace
          • Executing the class body
          • Creating the class object (not instance)
          • Executing the class decorators
          • Creating the class instance
          • Example
        • Storing class attributes in definition order
          • The classic solution without metaclasses
          • Using metaclasses to get a sorted namespace
        • Summary
      • 9. Documentation How to Use Sphinx and reStructuredText
        • The reStructuredText syntax
          • Getting started with reStructuredText
          • Inline markup
          • Headers
          • Lists
            • Enumerated list
            • Bulleted list
            • Option list
            • Definition list
            • Nested lists
          • Links, references, and labels
          • Images
          • Substitutions
          • Blocks, code, math, comments, and quotes
          • Conclusion
        • The Sphinx documentation generator
          • Getting started with Sphinx
            • Using sphinx-quickstart
            • Using sphinx-apidoc
          • Sphinx directives
            • The table of contents tree directive (toctree)
            • Autodoc, documenting Python modules, classes, and functions
          • Sphinx roles
        • Documenting code
          • Documenting a class with the Sphinx style
          • Documenting a class with the Google style
          • Documenting a class with the NumPy style
          • Which style to choose
        • Summary
      • 10. Testing and Logging Preparing for Bugs
        • Using examples as tests with doctest
          • A simple doctest example
          • Writing doctests
          • Testing with pure documentation
          • The doctest flags
            • True and False versus 1 and 0
            • Normalizing whitespace
            • Ellipsis
          • Doctest quirks
            • Testing dictionaries
            • Testing floating-point numbers
            • Times and durations
        • Testing with py.test
          • The difference between the unittest and py.test output
          • The difference between unittest and py.test tests
            • Simplifying assertions
            • Parameterizing tests
            • Automatic arguments using fixtures
              • Cache
              • Custom fixtures
            • Print statements and logging
            • Plugins
              • pytest-cov
              • pytest-pep8 and pytest-flakes
              • Configuring plugins
        • Mock objects
          • Using unittest.mock
          • Using py.test monkeypatch
        • Logging
          • Configuration
            • Basic logging configuration
            • Dictionary configuration
            • JSON configuration
            • Ini file configuration
            • The network configuration
          • Logger
            • Usage
        • Summary
      • 11. Debugging Solving the Bugs
        • Non-interactive debugging
          • Inspecting your script using trace
          • Debugging using logging
          • Showing call stack without exceptions
          • Debugging asyncio
          • Handling crashes using faulthandler
        • Interactive debugging
          • Console on demand
          • Debugging using pdb
            • Breakpoints
            • Catching exceptions
            • Commands
          • Debugging using ipdb
          • Other debuggers
          • Debugging services
        • Summary
      • 12. Performance Tracking and Reducing Your Memory and CPU Usage
        • What is performance?
        • Timeit comparing code snippet performance
        • cProfile finding the slowest components
          • First profiling run
          • Calibrating your profiler
          • Selective profiling using decorators
          • Using profile statistics
        • Line profiler
        • Improving performance
          • Using the right algorithm
          • Global interpreter lock
          • Try versus if
          • Lists versus generators
          • String concatenation
          • Addition versus generators
          • Map versus generators and list comprehensions
          • Caching
          • Lazy imports
          • Using optimized libraries
          • Just-in-time compiling
          • Converting parts of your code to C
        • Memory usage
          • Tracemalloc
          • Memory profiler
          • Memory leaks
          • Reducing memory usage
            • Generators versus lists
            • Recreating collections versus removing items
            • Using slots
        • Performance monitoring
        • Summary
      • 13. Multiprocessing When a Single CPU Core Is Not Enough
        • Multithreading versus multiprocessing
        • Hyper-threading versus physical CPU cores
        • Creating a pool of workers
        • Sharing data between processes
        • Remote processes
          • Distributed processing using multiprocessing
          • Distributed processing using IPyparallel
            • ipython_config.py
            • ipython_kernel_config.py
            • ipcontroller_config.py
            • ipengine_config.py
            • ipcluster_config.py
        • Summary
      • 14. Extensions in C/C++, System Calls, and C/C++ Libraries
        • Introduction
          • Do you need C/C++ modules?
          • Windows
          • OS X
          • Linux/Unix
        • Calling C/C++ with ctypes
          • Platform-specific libraries
            • Windows
            • Linux/Unix
            • OS X
            • Making it easy
          • Calling functions and native types
          • Complex data structures
          • Arrays
          • Gotchas with memory management
        • CFFI
          • Complex data structures
          • Arrays
          • ABI or API?
          • CFFI or ctypes?
        • Native C/C++ extensions
          • A basic example
          • C is not Python size matters
          • The example explained
            • static
            • PyObject*
            • Parsing arguments
          • C is not Python errors are silent or lethal
          • Calling Python from C handling complex types
        • Summary
      • 15. Packaging Creating Your Own Libraries or Applications
        • Installing packages
        • Setup parameters
        • Packages
        • Entry points
          • Creating global commands
          • Custom setup.py commands
        • Package data
        • Testing packages
          • Unittest
          • py.test
          • Nosetests
        • C/C++ extensions
          • Regular extensions
          • Cython extensions
        • Wheels the new eggs
          • Distributing to the Python Package Index
        • Summary
    • A. Bibliography
    • Index
  • Tytuł: Python: Journey from Novice to Expert. Journey from Novice to Expert
  • Autor: Fabrizio Romano, Dusty Phillips, Rick van Hattem
  • Tytuł oryginału: Python: Journey from Novice to Expert. Journey from Novice to Expert
  • ISBN: 9781787120761, 9781787120761
  • Data wydania: 2016-08-31
  • Format: Ebook
  • Identyfikator pozycji: e_3cyk
  • Wydawca: Packt Publishing