Login
Search manual

Details

Title MASTERING PYTHON: write powerful and efficient code using the full range of python's capabilities.
Creators HATTEM RICK VAN.
Imprint [S.l.]: PACKT PUBLISHING LIMITED, 2022
Collection Электронные книги зарубежных издательств ; Общая коллекция
Subjects Python (Computer program language) ; EBSCO eBooks
Document type Other
File type PDF
Language English
Rights Доступ по паролю из сети Интернет (чтение, печать, копирование)
Record key on1319198748
Record create date 5/21/2022

Allowed Actions

pdf/3286770.pdf –
Action 'Read' will be available if you login or access site from another network Action 'Download' will be available if you login or access site from another network
epub/3286770.epub –
Action 'Download' will be available if you login or access site from another network
Group Anonymous
Network Internet
Network User group Action
ILC SPbPU Local Network All
Read Print Download
Internet Authorized users SPbPU
Read Print Download
Internet Anonymous
  • Preface
  • Getting Started – One Environment per Project
    • Virtual environments
      • Why virtual environments are a good idea
      • Using venv and virtualenv
        • Creating a venv
        • Activating a venv/virtualenv
        • Installing packages
      • Using pyenv
      • Using Anaconda
        • Getting started with Anaconda Navigator
        • Getting started with conda
    • Managing dependencies
      • Using pip and a requirements.txt file
      • Version specifiers
      • Installing through source control repositories
      • Additional dependencies using extras
      • Conditional dependencies using environment markers
      • Automatic project management using poetry
        • Creating a new poetry project
        • Adding dependencies
        • Upgrading dependencies
        • Running commands
      • Automatic dependency tracking using pipenv
        • Updating your packages
        • Deploying to production
        • Running cron commands
    • Exercises
      • Reading the Python Enhancement Proposals (PEPs)
      • Combining pyenv and poetry or pipenv
      • Converting an existing project to a poetry project
    • Summary
  • Interactive Python Interpreters
    • The Python interpreter
      • Modifying the interpreter
        • Enabling and enhancing autocompletion
    • Alternative interpreters
      • bpython
        • Rewinding your session
        • Reloading modules
      • ptpython
      • IPython and Jupyter
        • Basic interpreter usage
        • Saving and loading sessions
        • Regular Python prompt/doctest mode
        • Introspection and help
        • Autocompletion
        • Jupyter
        • Installing Jupyter
        • IPython summary
    • Exercises
    • Summary
  • Pythonic Syntax and Common Pitfalls
    • A brief history of Python
    • Code style – What is Pythonic code?
      • Whitespace instead of braces
      • Formatting strings – printf, str.format, or f-strings?
        • Simple formatting
        • Named variables
        • Arbitrary expressions
      • PEP 20, 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
        • Hard to explain, easy to explain
        • Namespaces are one honking great idea
      • Explaining PEP 8
        • Duck typing
        • Differences between value and identity comparisons
        • Loops
        • Maximum line length
      • Verifying code quality, pep8, pyflakes, and more
      • Recent additions to the Python syntax
        • PEP 572: Assignment expressions/the walrus operator
        • PEP 634: Structural pattern matching, the switch statement
    • Common pitfalls
      • Scope matters!
        • Global variables
        • Mutable function default arguments
        • Class properties
      • Overwriting and/or creating extra built-ins
      • Modifying while iterating
      • Catching and storing exceptions
      • Late binding and closures
      • Circular imports
      • Import collisions
    • Summary
  • Pythonic Design Patterns
    • Time complexity – The big O notation
    • Core collections
      • list – A mutable list of items
      • dict – A map of items
      • set – Like a dict without values
      • tuple – The immutable list
    • Pythonic patterns using advanced collections
      • Smart data storage with type hinting using dataclasses
      • Combining multiple scopes with ChainMap
      • Default dictionary values using defaultdict
      • enum – A group of constants
      • Sorting collections using heapq
      • Searching through sorted collections using bisect
      • Global instances using Borg or Singleton patterns
      • No need for getters and setters with properties
      • Dict union operators
    • Exercises
    • Summary
  • Functional Programming – Readability Versus Brevity
    • Functional programming
      • Purely functional
      • Functional programming and Python
      • Advantages of functional programming
    • list, set, and dict comprehensions
      • Basic list comprehensions
      • set comprehensions
      • dict comprehensions
      • Comprehension pitfalls
    • lambda functions
      • The Y combinator
    • functools
      • partial – Prefill function arguments
      • reduce – Combining pairs into a single result
        • Implementing a factorial function
        • Processing trees
        • Reducing in the other direction
    • itertools
      • accumulate – reduce with intermediate results
      • chain – Combining multiple results
      • 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
    • Exercises
    • Summary
  • Decorators – Enabling Code Reuse by Decorating
    • Decorating functions
      • Generic function decorators
      • The importance of functools.wraps
      • Chaining or nesting decorators
      • Registering functions using decorators
      • 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 – Making classes sortable
    • Useful decorators
      • Single dispatch – Polymorphism in Python
      • contextmanager — with statements made easy
      • Validation, type checks, and conversions
      • Useless warnings – How to ignore them safely
    • Exercises
    • Summary
  • Generators and Coroutines – Infinity, One Step at a Time
    • Generators
      • Creating generators
      • Creating infinite generators
      • Generators wrapping iterables
      • Generator comprehensions
      • Class-based generators and iterators
    • Generator examples
      • Breaking an iterable up into chunks/groups
      • itertools.islice – Slicing iterables
      • itertools.chain – Concatenating multiple iterables
      • itertools.tee – Using an output multiple times
      • contextlib.contextmanager – Creating context managers
    • Coroutines
      • A basic example
      • Priming
      • Closing and throwing exceptions
      • Mixing generators and coroutines
      • Using the state
    • Exercises
    • Summary
  • 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
    • Automatically registering plugin systems
      • Importing plugins on-demand
      • Importing plugins through configuration
      • Importing plugins through the filesystem
    • Dataclasses
    • 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
    • Exercises
    • Summary
  • Documentation – How to Use Sphinx and reStructuredText
    • Type hinting
      • Basic example
      • Custom types
      • Generics
      • Type checking
      • Python type interface files
      • Type hinting conclusion
    • reStructuredText and Markdown
      • Getting started with reStructuredText
      • Getting started with Markdown
      • Inline markup
      • Headers
        • Headers with reStructuredText
        • Headers with Markdown
      • Lists
        • Enumerated lists
        • Bulleted lists
        • Option lists
        • Definition lists (reST only)
        • Nested lists
      • Links, references, and labels
      • Images
        • Images with reStructuredText
        • Images with Markdown
      • Substitutions
      • Blocks, code, math, comments, and quotes
      • Conclusion
    • The Sphinx documentation generator
      • Getting started with Sphinx
        • Using sphinx-quickstart
        • Using sphinx-apidoc
      • Sphinx directives
      • 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
    • Exercises
    • Summary
  • Testing and Logging – Preparing for Bugs
    • Using documentation as tests with doctest
      • A simple doctest example
      • Writing doctests
      • Testing with 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
        • Print statements and logging
        • Plugins
    • Mock objects
      • Using unittest.mock
      • Using py.test monkeypatch
    • Testing multiple environments with tox
      • Getting started with tox
      • The tox.ini config file
      • Running tox
    • Logging
      • Configuration
        • Basic logging configuration
        • Dictionary configuration
        • JSON configuration
        • ini file configuration
        • The network configuration
      • Logger
        • Usage
        • Formatting
        • Modern formatting using f-strings and str.format
      • Logging pitfalls
      • Debugging loggers
    • Exercises
    • Summary
  • Debugging – Solving the Bugs
    • Non-interactive debugging
      • Inspecting your script using trace
      • Debugging using logging
      • Showing the call stack without exceptions
      • Handling crashes using faulthandler
    • Interactive debugging
      • Console on demand
      • Debugging using Python debugger (pdb)
        • Breakpoints
        • Catching exceptions
        • Aliases
        • commands
      • Debugging with IPython
      • Debugging with Jupyter
      • Other debuggers
        • Debugging services
    • Exercises
    • Summary
  • Performance – Tracking and Reducing Your Memory and CPU Usage
    • What is performance?
    • Measuring CPU performance and execution time
      • 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 – Tracking performance per line
    • Improving execution time
      • 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 slots
      • Using optimized libraries
      • Just-in-time compiling
      • Converting parts of your code to C
    • Memory usage
      • tracemalloc
      • Memory Profiler
      • Memory leaks
        • Circular references
        • Analyzing memory usage using the garbage collector
        • Weak references
        • Weakref limitations and pitfalls
      • Reducing memory usage
        • Generators versus lists
        • Recreating collections versus removing items
        • Using slots
    • Performance monitoring
    • Exercises
    • Summary
  • asyncio – Multithreading without Threads
    • Introduction to asyncio
      • Backward compatibility and async/await statements
        • Python 3.4
        • Python 3.5
        • Python 3.7
      • A basic example of parallel execution
      • asyncio concepts
        • Coroutines, Futures, and Tasks
        • Event loops
        • Executors
    • Asynchronous examples
      • Processes
      • Interactive processes
      • Echo client and server
      • Asynchronous file operations
      • Creating async generators to support async for
      • Asynchronous constructors and destructors
    • Debugging asyncio
      • Forgetting to await a coroutine
      • Slow blocking functions
      • Forgetting to check the results or exiting early
      • Exiting before all tasks are done
    • Exercises
    • Summary
  • Multiprocessing – When a Single CPU Core Is Not Enough
    • The Global Interpreter Lock (GIL)
      • The use of multiple threads
      • Why do we need the GIL?
      • Why do we still have the GIL?
    • Multiple threads and processes
      • Basic examples
        • concurrent.futures
        • threading
        • multiprocessing
      • Cleanly exiting long-running threads and processes
      • Batch processing using concurrent.futures
      • Batch processing using multiprocessing
    • Sharing data between threads and processes
      • Shared memory between processes
      • Thread safety
      • Deadlocks
      • Thread-local variables
    • Processes, threads, or a single thread?
      • threading versus concurrent.futures
      • multiprocessing versus concurrent.futures
    • Hyper-threading versus physical CPU cores
    • Remote processes
      • Distributed processing using multiprocessing
      • Distributed processing using Dask
        • Installing Dask
        • Basic example
        • Running a single thread
        • Distributed execution across multiple machines
      • Distributed processing using ipyparallel
        • ipython_config.py
        • ipython_kernel_config.py
        • ipcontroller_config.py
        • ipengine_config.py
        • ipcluster_config.py
    • Summary
  • Scientific Python and Plotting
    • Installing the packages
    • Arrays and matrices
      • NumPy – Fast arrays and matrices
      • Numba – Faster Python on CPU or GPU
      • SciPy – Mathematical algorithms and NumPy utilities
        • Sparse matrices
      • Pandas – Real-world data analysis
        • Input and output options
        • Pivoting and grouping
        • Merging
        • Rolling or expanding windows
      • Statsmodels – Statistical models on top of Pandas
      • xarray – Labeled arrays and datasets
      • STUMPY – Finding patterns in time series
    • Mathematics and precise calculations
      • gmpy2 – Fast and precise calculations
      • Sage – An alternative to Mathematica/Maple/MATLAB
      • mpmath – Convenient, precise calculations
      • SymPy – Symbolic mathematics
      • Patsy – Describing statistical models
    • Plotting, graphing, and charting
      • Matplotlib
        • Seaborn
        • Yellowbrick
      • Plotly
      • Bokeh
      • Datashader
    • Exercises
    • Summary
  • Artificial Intelligence
    • Introduction to artificial intelligence
      • Types of AI
    • Installing the packages
    • Image processing
      • scikit-image
        • Installing scikit-image
        • Edge detection
        • Face detection
        • scikit-image overview
      • OpenCV
        • Installing OpenCV for Python
        • Edge detection
        • Object detection
      • OpenCV versus scikit-image
    • Natural language processing
      • NLTK – Natural Language Toolkit
      • spaCy – Natural language processing with Cython
      • Gensim – Topic modeling for humans
    • Machine learning
      • Types of machine learning
        • Supervised learning
        • Reinforcement learning
        • Unsupervised learning
        • Combinations of learning methods
        • Deep learning
      • Artificial neural networks and deep learning
        • Tensors
        • PyTorch – Fast (deep) neural networks
        • PyTorch Lightning and PyTorch Ignite – High-level PyTorch APIs
        • Skorch – Mixing PyTorch and scikit-learn
        • TensorFlow/Keras – Fast (deep) neural networks
        • TensorFlow versus PyTorch
      • Evolutionary algorithms
      • Support-vector machines
      • Bayesian networks
    • Versatile AI libraries and utilities
      • scikit-learn – Machine learning in Python
        • Supervised learning
        • Unsupervised learning
      • auto-sklearn – Automatic scikit-learn
      • mlxtend – Machine learning extensions
      • scikit-lego – scikit-learn utilities
      • XGBoost – eXtreme Gradient Boosting
      • Featuretools – Feature detection and prediction
      • Snorkel – Improving your ML data automatically
      • TPOT – Optimizing ML models using genetic programming
    • Exercises
    • Summary
  • Extensions in C/C++, System Calls, and C/C++ Libraries
    • Setting up tooling
      • 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
    • Exercises
    • Summary
  • Packaging – Creating Your Own Libraries or Applications
    • Introduction to packages
      • Types of packages
        • Wheels – The new eggs
        • Source packages
      • Package tools
    • Package versioning
    • Building packages
      • Packaging using pyproject.toml
        • Creating a basic package
        • Installing packages for development
        • Adding code and data
        • Adding executable commands
        • Managing dependencies
        • Building the package
        • Building C/C++ extensions
      • Packaging using setuptools with setup.py or setup.cfg
        • Creating a basic package
        • Installing the package for development
        • Adding packages
        • Adding package data
        • Managing dependencies
        • Adding executable commands
        • Building the package
    • Publishing packages
      • Adding URLs
      • PyPI trove classifiers
      • Uploading to PyPI
    • C/C++ extensions
      • Regular C/C++ extensions
      • Cython extensions
    • Testing
      • unittest
      • py.test
    • Exercises
    • Summary
  • Other Books You May Enjoy
  • Index
  • _gjdgxs
  • _gjdgxs
pdf/3286770.pdf

Access count: 2 
Last 30 days: 0

Detailed usage statistics

epub/3286770.epub

Access count: 0 
Last 30 days: 0

Detailed usage statistics