Index
A
- acceptance tests / Testing your application
- accepted content types / Understanding accepted and returned content types
- active link, template patterns
- issue details / Problem details
- solution details / Solution details
- admin
- models, enhancing / Enhancing models for the admin
- protecting / Protecting the admin
- feature flags / Pattern – feature flags
- admin interface
- using / Using the admin interface
- admin interface customizations
- about / Admin interface customizations
- heading, changed / Changing the heading
- base and stylesheets, changing / Changing the base and stylesheets
- Bootstrap-themed admin / Bootstrap-themed admin
- complete overhauls / Complete overhauls
- anonymous functions / Anonymous functions
- API
- browsing, with resources / Browsing the API with resources and relationships
- browsing, with relationships / Browsing the API with resources and relationships
- API pattern
- about / API patterns
- human browsable interface / Pattern – human browsable interface
- infinite scrolling / Pattern – Infinite Scrolling
- application
- testing / Testing your application
- assertions / Assertions, Assertions
- asynchronous
- need for / Why asynchronous?
- code, pitfalls / Pitfalls of asynchronous code
- asynchronous, pitfalls
- race condition / Pitfalls of asynchronous code
- starvation / Pitfalls of asynchronous code
- deadlock / Pitfalls of asynchronous code
- debugging challenge / Pitfalls of asynchronous code
- order preservation / Pitfalls of asynchronous code
- Asynchronous JavaScript And XML (AJAX) / Solution details
- asynchronous patterns
- about / Asynchronous patterns
- endpoint callback pattern / Endpoint callback pattern
- asynchronous scraper / Asynchronous web-scraping
- Asynchronous Server Gateway Interface (ASGI) / Entering Channels
- asynchronous solutions
- for Django / Asynchronous solutions for Django
- Celery / Asynchronous solutions for Django
- Django channels / Asynchronous solutions for Django
- asynchronous web-scraping / Asynchronous web-scraping
- asyncio
- about / Understanding asyncio
- versus threads / asyncio versus threads
- classic web-scraper, example / The classic web-scraper example
- concurrency / Concurrency is not parallelism
- parallelism / Concurrency is not parallelism
- asyncio module
- reference / Downloading random pictures with asyncio
- attribute
- shadowing / Attribute shadowing
- authenticated HTTP PATCH requests
- creating, with Postman / Making authenticated HTTP PATCH requests with Postman
- authenticated requests
- creating / Making authenticated requests
- authentication classes / Learning about the authentication classes
B
- backend performance
- about / Backend performance
- templates / Templates
- database / Database
- caching / Caching
- base and stylesheets
- changing / Changing the base and stylesheets
- rich-text editor, adding for WYSIWYG editing / Adding a rich-text editor for WYSIWYG editing
- base image / Virtual machines or Docker
- batch sudoku-solver
- about / Example two – batch sudoku-solver
- Sudoku / What is Sudoku?
- implementing, in Python / Implementing a sudoku-solver in Python
- solving, with multiprocessing / Solving sudoku with multiprocessing
- binary mode
- files, reading / Reading and writing in binary mode
- files, writing / Reading and writing in binary mode
- binary search / Where to inspect
- Bitbucket
- reference / Exceptions
- black-box tests / Testing your application
- Booleans / Booleans
- Bootstrap
- using / Using Bootstrap
- project skeleton, finding / Using Bootstrap
- package, using / Using Bootstrap
- manually copy / Using Bootstrap
- URL, for downloading / Using Bootstrap
- about / But they all look the same!
- lightweight alternatives / Lightweight alternatives
- boundary / Boundaries and granularity
- branching / Conditional programming
- break statement / The break and continue statements
- browsable API
- HTTP GET requests, creating / Making HTTP GET requests with the browsable API
- HTTP POST requests, creating / Making HTTP POST requests with the browsable API
- HTTP PUT requests, creating / Making HTTP PUT requests with the browsable API
- HTTP OPTIONS requests, creating / Making HTTP OPTIONS requests with the browsable API
- HTTP DELETE requests, creating / Making HTTP DELETE requests with the browsable API
- used, for pagination testing / Using the browsable API to test pagination, filtering, searching, and ordering
- used, for testing filter functionality / Using the browsable API to test pagination, filtering, searching, and ordering
- used, for testing search functionality / Using the browsable API to test pagination, filtering, searching, and ordering
- used, for testing order functionality / Using the browsable API to test pagination, filtering, searching, and ordering
- built-in data types
- numbers / Numbers
- immutable sequences / Immutable sequences
- mutable sequences / Mutable sequences
- set types / Set types
- mapping types / Mapping types – dictionaries
- collections module / The collections module
- built-in exceptions hierarchy
- reference / Exceptions
- built-in functions / Built-in functions
- built-in types
- generation behavior / Generation behavior in built-ins
- byte arrays / Byte arrays
- bytes / Strings and bytes
C
- caching, backend performance
- cached session backend / Cached session backend
- caching frameworks / Caching frameworks
- caching patterns / Caching patterns
- case examples, concurrent execution
- concurrent mergesort / Example one – concurrent mergesort
- batch sudoku-solver / Example two – batch sudoku-solver
- random pictures, downloading / Example three – downloading random pictures
- Celery
- working with / Working with Celery
- working / How Celery works
- best practices / Celery best practices
- failure, handling / Handling failure
- idempotent tasks / Idempotent tasks
- writing, avoid to shared or global state / Avoid writing to shared or global state
- passing complex objects, avoid to tasks / Avoid passing complex objects to tasks
- ChainMap / ChainMap
- classes / Objects and classes
- Classes section, Python tutorial
- reference / Scopes
- classic web-scraper
- example / The classic web-scraper example
- synchronous web-scraping / Synchronous web-scraping
- asynchronous web-scraping / Asynchronous web-scraping
- Clickjacking
- about / Clickjacking
- Django, need for / How Django helps
- closures / Debugging with a custom function
- code
- guidelines / Guidelines on how to write good code
- documenting / Documenting your code
- collections module
- about / The collections module
- namedtuple / namedtuple
- defaultdict / defaultdict
- ChainMap / ChainMap
- combinatoric generators / Combinatoric generators
- complex numbers / Complex numbers
- composition / Inheritance and composition
- comprehensions
- about / The map, zip, and filter functions, Comprehensions
- filtering / Filtering a comprehension
- avoiding / Don't overdo comprehensions and generators
- concurrency
- about / Concurrency versus parallelism
- versus parallelism / Concurrency versus parallelism
- concurrent execution
- in Python / Concurrent execution in Python
- thread, starting / Starting a thread
- process, starting / Starting a process
- thread, stopping / Stopping threads and processes
- process, stopping / Stopping threads and processes, Stopping a process
- multiple threads, spawning / Spawning multiple threads
- race conditions, dealing with / Dealing with race conditions
- local data, implementing for thread / A thread's local data
- thread communication / Thread and process communication, Thread communication
- process communication / Thread and process communication
- events, sending / Sending events
- inter-process communication, with queues / Inter-process communication with queues
- thread pools / Thread and process pools
- process pools / Thread and process pools
- process, using for timeout addition to function / Using a process to add a timeout to a function
- case examples / Case examples
- concurrent mergesort
- about / Example one – concurrent mergesort
- single-thread mergesort / Single-thread mergesort
- single-thread multipart mergesort / Single-thread multipart mergesort
- multithreaded mergesort / Multithreaded mergesort
- multiprocess mergesort / Multiprocess mergesort
- conditional programming
- about / Conditional programming
- elif / A specialized else – elif
- ternary operator / The ternary operator
- console / Your friend, the console
- console editors
- using / Using console editors
- constraint propagation / What is Sudoku?
- constructor / Initializing an instance
- content delivery network (CDN) / Frontend performance
- content negotiation classes
- advantages / Taking advantage of content negotiation classes
- content types
- working with / Working with different content types
- context-switching / Context-switching
- contextlib
- context manager
- used, for opening files / Using a context manager to open a file
- continue statement / The break and continue statements
- controlling / Controlling, serialization, and deserialization
- CPython
- reference link / Some performance considerations
- Create, Read, Update and Delete (CRUD) / Understanding CRUD operations with Django views and the request methods
- Cross-Site Request Forgery (CSRF) / Creating Django views combined with serializer classes
- Cross-site request forgery (CSRF)
- about / Cross-site request forgery
- Django, need for / How Django helps
- Django, avoiding / Where Django might not help
- cross-site request forgery (CSRF) / Understanding CSRF
- Cross-site scripting (XSS)
- about / Cross-site scripting
- cookies, valuable / Why are your cookies valuable?
- Django, need for / How Django helps
- Django, avoiding / Where Django might not help
- CRUD views, form patterns
- issue details / Problem details
- solution details / Solution details
- CSV generator
- testing / Testing a CSV generator
- Curl
- installing / Installing Curl
- URL / Installing Curl
- custom exceptions / Exceptions
- custom function
- debugging / Debugging with a custom function
- custom iterator
- writing / Writing a custom iterator
- customized pagination classes
- working with / Working with customized pagination classes
- customized permission classes
- object-level permissions / Working with object-level permissions via customized permission classes
- Cygwin
- URL / Installing Curl
D
- data
- persisting, on disk / Persisting data on disk
- serializing, with pickle / Serializing data with pickle
- saving, with shelve / Saving data with shelve
- saving, to database / Saving data to a database
- database
- data, saving / Saving data to a database
- analyzing / Analyzing the database
- Django table, generation / Understanding the table generated by Django
- updating, without race conditions / Database updates without race conditions
- database management systems (DBMS) / Saving data to a database
- data classes, Python
- reference link / Data classes
- Data Compression and Archiving
- data interchange formats
- about / Data interchange formats
- JSON, working with / Working with JSON
- custom encoding, with JSON / Custom encoding/decoding with JSON
- custom decoding, with JSON / Custom encoding/decoding with JSON
- Data Model, official Python documentation
- reference / A proper introduction
- data structures
- selecting / How to choose data structures
- deadlocks / Deadlocks
- debugging
- techniques / Debugging techniques
- with print function / Debugging with print
- with custom function / Debugging with a custom function
- traceback, inspecting / Inspecting the traceback
- with Python debugger / Using the Python debugger
- log files, inspecting / Inspecting log files
- other techniques / Other techniques
- via profiling / Profiling
- with assertions / Assertions
- information, obtaining / Where to find information
- decimal numbers / Fractions and decimals
- decorate-sort-undecorate
- using, URL / map
- decoration / Decorators
- decorator factory / A decorator factory
- decorators
- about / Decorators
- reference link / Decorators
- working, as wrappers / Understanding decorators that work as wrappers
- used, for enabling parsers / Using decorators to enable different parsers and renderers
- used, for enabling renderers / Using decorators to enable different parsers and renderers
- defaultdict / defaultdict
- default values / Keyword arguments and default values
- deployment tools
- about / Deployment tools
- fabric / Fabric
- configuration management / Configuration management
- deserialization
- destructive tests / Testing your application
- determinist profiling / Profiling Python
- development server
- launching / Launching Django's development server
- HTTP GET requests, creating to target instances collection / Making HTTP GET requests that target a collection of instances
- HTTP GET requests, creating to target single instance / Making HTTP GET requests that target a single instance
- HTTP POST requests, creating / Making HTTP POST requests
- HTTP PUT requests, creating / Making HTTP PUT requests
- HTTP DELETE requests, creating / Making HTTP DELETE requests
- HTTP GET requests, creating with Postman / Making HTTP GET requests with Postman
- dict comprehensions / dict comprehensions
- dictionaries / Mapping types – dictionaries
- directories
- working with / Working with files and directories
- existence, checking / Checking for file and directory existence
- manipulating / Manipulating files and directories
- content, inspecting / Directory content
- compression / File and directory compression
- discounts
- applying / Applying discounts
- dispatcher / Applying discounts
- Django
- installing, in isolated environment / Installing Django and Django REST frameworks in an isolated environment
- app, creating / Creating an app with Django
- folders / Understanding Django folders, files, and configurations
- files / Understanding Django folders, files, and configurations
- configurations / Understanding Django folders, files, and configurations
- authentication / Understanding authentication and permissions in Django, the Django REST framework, and RESTful Web Services
- permissions / Understanding authentication and permissions in Django, the Django REST framework, and RESTful Web Services
- superuser, creating / Creating the superuser for Django
- user, creating / Creating a user for Django
- forms in / Forms in Django
- Django Channels
- entering / Entering Channels
- notifications, listening with WebSockets / Listening to notifications with WebSockets
- Celery, differences / Differences from Celery
- Django filters
- types, working with / Working with different types of Django filters
- Django REST framework (DRF)
- installing, in isolated environment / Installing Django and Django REST frameworks in an isolated environment
- about / Defining the requirements for our first RESTful Web Service, Understanding authentication and permissions in Django, the Django REST framework, and RESTful Web Services
- throttling classes, purpose / Learning the purpose of the different throttling classes in the Django REST framework
- throttling policies, configuring / Configuring throttling policies in the Django REST framework
- Django Rest framework (DRF)
- about / Django Rest framework
- Public Posts API, improving / Improving the Public Posts API
- IDs, hiding / Hiding the IDs
- Django shell
- Django Template Language (DTL)
- features / Understanding Django's template language features
- about / Understanding Django's template language features
- variables / Variables
- attributes / Attributes
- filters / Filters
- philosophy / Philosophy – don't invent a programming language
- Django views
- creating, with serializer classes / Creating Django views combined with serializer classes
- about / Understanding CRUD operations with Django views and the request methods
- URLs, routing / Routing URLs to Django views and functions
- Docker
- about / Virtual machines or Docker
- microservices / Microservices
- Dockerfile / Virtual machines or Docker
- docstrings / Documenting your code
- don't repeat yourself (DRY) principle / How do we use modules and packages?
- double-precision floating-point format
- reference / Real numbers
- dunder methods / Going beyond next
- dynamic form generation, form patterns
- issue details / Problem details
- solution details / Solution details
E
- elif condition / A specialized else – elif
- else clause / A special else clause
- endpoint callback pattern
- about / Endpoint callback pattern
- publish-subscribe pattern / Publish-subscribe pattern
- polling pattern / Polling pattern
- enums / Enums
- exception / A special else clause, Exceptions
- export function
- testing / Testing the export function
F
- fabric, deployment tools
- deployment steps / Typical deployment steps
- feature flags, admin
- issue details / Problem details
- solution details / Solution details
- trails / Solution details
- A/B testing / Solution details
- performance testing / Solution details
- limit externalities / Solution details
- Fibonacci sequence
- example / One last example
- files
- opening / Opening files
- opening, with context manager / Using a context manager to open a file
- reading / Reading and writing to a file
- writing / Reading and writing to a file
- overriding, protecting against / Protecting against overriding an existing file
- checking / Checking for file and directory existence
- manipulating / Manipulating files and directories
- compression / File and directory compression
- filter backend classes
- configuring / Configuring filter backend classes
- filter function / filter
- filter functionality
- adding / Adding filtering, searching, and ordering
- testing, with browsable API / Using the browsable API to test pagination, filtering, searching, and ordering
- filters / Inspecting log files
- for loop / The for loop
- formatted string literals / String formatting
- formatters / Inspecting log files
- form patterns
- about / Form patterns
- dynamic form generation / Pattern – dynamic form generation
- user-based forms / Pattern – user-based forms
- multiple form actions, handling in view / Pattern – multiple form actions per view
- CRUD views / Pattern – CRUD views
- form processing
- with class-based views / Form processing with class-based views
- forms
- working / How forms work
- empty form / How forms work
- filled form / How forms work
- submitted form, with errors / How forms work
- submitted form without errors / How forms work
- in Django / Forms in Django
- data cleaning / Why does data need cleaning?
- displaying / Displaying forms
- crisp / Time to be crisp
- fractions / Fractions and decimals
- front-end tests / Testing your application
- frontend performance
- cache infinitely / Frontend performance
- static asset manager / Frontend performance
- functional tests / Testing your application
- Function as a Service (FaaS) / Serverless
- functions
- about / How do we use modules and packages?
- benefits / Why use functions?
- code duplication, reducing / Reducing code duplication
- complex task, splitting / Splitting a complex task
- implementation details, hiding / Hiding implementation details
- readability, improving / Improving readability
- traceability, improving / Improving traceability
- tips / A few useful tips
- recursive functions / Recursive functions
- anonymous functions / Anonymous functions
- attributes / Function attributes
- built-in functions / Built-in functions
- example / One final example
- URLs, routing / Routing URLs to Django views and functions
G
- generalizations
- unpacking / Additional unpacking generalizations
- generator expressions / Generator expressions
- generator functions / Generator functions, Going beyond next
- generators
- about / Generators
- avoiding / Don't overdo comprehensions and generators
- GitHub
- reference / Exceptions
- global interpreter lock (GIL) / The Global Interpreter Lock, Concurrency is not parallelism
- global statement / The global and nonlocal statements
- granularity / Boundaries and granularity
- Graphical User Interface (GUI) / Installing the Postman REST client
- graphical user interface (GUI) / Running Python as a GUI application
- Graphite / Monitoring
- gray-box testing / Testing your application
- GUI application
- Python, running as / Running Python as a GUI application
- Gunicorn/Django container / Microservices
H
- handlers / Inspecting log files
- hashability / Set types
- Haskell
- reference link / Comprehensions
- hosting
- about / Hosting
- Platform as a Service (PaaS) / Platform as a service
- virtual private server (VPS) / Virtual private servers
- serverless / Serverless
- approaches / Other hosting approaches
- HTTP DELETE requests
- creating / Making HTTP DELETE requests
- creating, with browsable API / Making HTTP DELETE requests with the browsable API
- HTTP GET requests
- creating, to target instance collection / Making HTTP GET requests that target a collection of instances
- creating, to target single instance / Making HTTP GET requests that target a single instance
- creating, with Postman / Making HTTP GET requests with Postman
- creating, with browsable API / Making HTTP GET requests with the browsable API
- HTTPie
- installing / Installing HTTPie
- HTTP OPTIONS requests
- creating, with browsable API / Making HTTP OPTIONS requests with the browsable API
- HTTP POST requests
- creating / Making HTTP POST requests
- creating, with Postman / Making HTTP POST requests with Postman
- creating, with browsable API / Making HTTP POST requests with the browsable API
- HTTP PUT requests
- creating / Making HTTP PUT requests
- creating, with browsable API / Making HTTP PUT requests with the browsable API
- HTTP requests
- creating / Making HTTP requests
- sending, with unsupported HTTP verbs / Sending HTTP requests with unsupported HTTP verbs
- human browsable interface, API pattern
- issue details / Problem details
- solution details / Solution details
I
- iCurlHTTP
- installing / Installing iCurlHTTP
- references / Installing iCurlHTTP
- immutable sequences
- about / Immutable sequences
- strings / Strings and bytes
- bytes / Strings and bytes
- tuples / Tuples
- imports
- relative imports / Relative imports
- in-memory stream
- using / Using an in-memory stream
- indexing / Indexing and slicing strings, About indexing and slicing
- infinite iterators / Infinite iterators
- infinite loop / The while loop
- infinite scrolling, API pattern
- issue details / Problem details
- solution details / Solution details
- inheritance / Inheritance and composition
- initializer / Objects and classes, Initializing an instance
- input/output / IO, streams, and requests
- input parameters
- about / Input parameters
- considerations / Argument-passing, Assignment to argument names doesn't affect the caller, Changing a mutable affects the caller
- specifying / How to specify input parameters
- positional arguments / Positional arguments
- keyword arguments / Keyword arguments and default values
- variable positional arguments / Variable positional arguments
- variable keyword arguments / Variable keyword arguments
- keyword-only arguments / Keyword-only arguments
- combining / Combining input parameters
- instance attributes / Class and object namespaces
- integer division / Integers
- integers / Integers
- Integrated Development Environments (IDEs) / Running the Python interactive shell, A note on IDEs, The property decorator
- integration tests / Testing your application
- inter-process communication (IPC) / Quick anatomy of a process
- iterable / Iterators and iterables, Writing a custom iterator
- iterators
- about / Iterators and iterables, Writing a custom iterator
- terminating, on shortest input sequence / Iterators terminating on the shortest input sequence
- itertools module
- reference / A quick peek at the itertools module
J
- JavaScript Object Notation (JSON)
- about / Working with JSON
- URL / Working with JSON
- custom encoding / Custom encoding/decoding with JSON
- custom decoding / Custom encoding/decoding with JSON
- Jenkins box / Testing guidelines
- Jinja2
K
- keyword-only arguments / Keyword-only arguments
- keyword arguments / Keyword arguments and default values
L
- lambdas / Anonymous functions
- library / How do we use modules and packages?
- list comprehension / Lists
- lists / Lists
- local, enclosing, global, built-in (LEGB) / Scopes, Scopes and name resolution
- locks
- using, with race condition / Locks to the rescue
- using / Scenario C – using a lock
- log files
- about / Inspecting log files
- inspecting / Inspecting log files
- loggers / Inspecting log files
- looping
- about / Looping
- for loop / The for loop
- while loop / The while loop
- break statement / The break and continue statements
- continue statement / The break and continue statements
- else clause / A special else clause
M
- magic methods / Objects and classes
- map function / map
- mapping types / Mapping types – dictionaries
- metaclasses / Objects and classes, The simplest Python class
- metaprogramming / The simplest Python class
- Method Resolution Order (MRO) / Method resolution order
- methods / A proper introduction
- microservice architectures / Inspecting log files
- migration
- executing / Running our initial migration
- about / Understanding migrations
- mixin classes / Configuring pagination classes
- mocks / Mock objects and patching
- models
- enhancing, for admin / Enhancing models for the admin
- model serializers
- advantages / Taking advantage of model serializers
- modules
- monitoring / Monitoring
- multiple form actions, form pattern
- issue details / Problem details
- solution details / Solution details
- multiple sequences
- iterating over / Iterating over multiple sequences
- multiple values
- returning / Returning multiple values
- multiprocessing
- about / Threads and processes – an overview
- advantages / Multithreading or multiprocessing?
- multithreading
- about / Threads and processes – an overview
- advantages / Multithreading or multiprocessing?
- mutable defaults / Avoid the trap! Mutable defaults
- mutable object / Debugging with a custom function
- mutable sequences
- about / Mutable sequences
- lists / Lists
- byte arrays / Byte arrays
N
- namedtuple / namedtuple
- NameError exception / Scopes
- name localization / Name localization
- name mangling / Private methods and name mangling
- name resolution / Scopes and name resolution
- names / Names and namespaces, About the names
- namespace / Names and namespaces
- nano
- using / Using console editors
- negative indexing / About indexing and slicing
- nested comprehensions / Nested comprehensions
- Nginx container / Microservices
- nonlocal statements / The global and nonlocal statements
- numbers
- about / Numbers
- integers / Integers
- Booleans / Booleans
- real numbers / Real numbers
- complex numbers / Complex numbers
- fractions / Fractions and decimals
- decimal numbers / Fractions and decimals
- NumPy
- about / What are the drawbacks?
O
- object-level permissions
- Object-oriented programming (OOP)
- about / Object-oriented programming (OOP)
- Python class, writing / The simplest Python class
- class namespaces / Class and object namespaces
- object namespaces / Class and object namespaces
- attribute, shadowing / Attribute shadowing
- self variable, using / Me, myself, and I – using the self variable
- instance, initializing / Initializing an instance
- inheritance / Inheritance and composition
- composition / Inheritance and composition
- base class, accessing / Accessing a base class
- multiple inheritance / Multiple inheritance
- Method Resolution Order (MRO) / Method resolution order
- class methods / Class and static methods, Class methods
- static methods / Static methods
- private methods / Private methods and name mangling
- name mangling / Private methods and name mangling
- property decorator / The property decorator
- operator overloading / Operator overloading
- polymorphism / Polymorphism – a brief overview
- data classes / Data classes
- Object-Relational Mapping (ORM) / Defining the requirements for our first RESTful Web Service
- object-relational mapping (ORM) / Saving data to a database
- objects
- operator overloading / Lists, Operator overloading
- order functionality
- adding / Adding filtering, searching, and ordering
- testing, with browsable API / Using the browsable API to test pagination, filtering, searching, and ordering
P
- package
- about / How is Python code organized?
- using / How do we use modules and packages?
- pagination
- about / Understanding pagination
- testing, with browsable API / Using the browsable API to test pagination, filtering, searching, and ordering
- pagination classes
- configuring / Configuring pagination classes
- Pandas
- about / What are the drawbacks?
- parallelism
- versus concurrency / Concurrency versus parallelism
- about / Concurrency versus parallelism
- patching / Mock objects and patching
- pathnames
- manipulating / Manipulating pathnames
- penetration tests / Testing your application
- PEP 8 / Guidelines on how to write good code
- reference / Importing objects
- PEP 373
- reference / Python 2 versus Python 3
- PEP 405
- virtual environment, creating / Creating a virtual environment with Python 3.x and PEP 405
- PEP428
- PEP 448
- reference / Additional unpacking generalizations
- PEP 3134
- reference / Inspecting the traceback
- performance
- improving / Improving Performance
- frontend performance / Frontend performance
- backend performance / Backend performance
- performance considerations / Some performance considerations
- performance tests / Testing your application
- permission policies
- setting / Setting permission policies
- permissions-related data
- including, to models / Including security and permissions-related data to models
- pickle
- used, for data serializing / Serializing data with pickle
- Platform as a Service (PaaS) / Platform as a service
- polymorphism / Polymorphism – a brief overview
- positional arguments / Positional arguments
- post/redirect/get (PRG) pattern / Form processing with class-based views
- PostgreSQL container / Microservices
- Postman
- HTTP POST requests, creating / Making HTTP GET requests with Postman, Making HTTP POST requests with Postman
- authenticated HTTP PATCH requests, creating / Making authenticated HTTP PATCH requests with Postman
- Postman app
- Postman REST client
- installing / Installing the Postman REST client
- prime generator / A prime generator
- prime number / A prime generator
- print function
- used, for debugging / Debugging with print
- process
- about / Threads and processes – an overview
- anatomy / Quick anatomy of a process
- properties / Properties of a process
- production environment
- about / The production environment
- web stack, selecting / Choosing a web stack
- stack components / Components of a stack
- profiling / When to profile?, Profiling
- properties / A proper introduction
- property decorator / The property decorator
- PyPy
- reference / What are the drawbacks?
- pytest
- unit testing / Getting ready for unit testing with pytest
- unit tests, discovering / Discovering and running unit tests with pytest
- unit tests, executing / Discovering and running unit tests with pytest, Running unit tests again with pytest
- Python
- about / Enter the Python, About Python
- portability / Portability
- coherence / Coherence
- developer productivity / Developer productivity
- extensive library / An extensive library
- software quality / Software quality
- software integration / Software integration
- satisfaction / Satisfaction and enjoyment
- drawbacks / What are the drawbacks?
- users / Who is using Python today?
- environment, setting up / Setting up the environment
- installing / Installing Python
- reference / Setting up the Python interpreter, Using the Python debugger
- running, as service / Running Python as a service
- running, as GUI application / Running Python as a GUI application
- execution model / Python's execution model
- culture / The Python culture
- profiling / Profiling Python
- concurrent execution / Concurrent execution in Python
- Python 2
- versus Python 3 / Python 2 versus Python 3
- Python 3.x
- virtual environment, creating / Creating a virtual environment with Python 3.x and PEP 405
- Python code
- organizing / How is Python code organized?
- Python debugger
- using / Using the Python debugger
- Pythonic / The Python culture
- Python interactive shell
- running / Running the Python interactive shell
- Python interpreter
- setting up / Setting up the Python interpreter
- Python Package Index (PyPI) / An extensive library
- Python program
- running / How you can run a Python program
- Python scripts
- running / Running Python scripts
- Python Tutor
- reference / Everything is an object
Q
- quality assurance (QA) / Testing your application
R
- race condition
- about / Race conditions
- scenario / Scenario A – race condition not happening, Scenario B – race condition happening
- locks, using / Locks to the rescue
- Rackspace / Other hosting approaches
- random pictures, downloading
- example / Example three – downloading random pictures
- with asyncio / Downloading random pictures with asyncio
- range
- iterating over / Iterating over a range
- real numbers / Real numbers
- recursive functions / Recursive functions
- regression tests / Testing your application
- relational algebra / Saving data to a database
- relational model / Saving data to a database
- relative imports
- about / Relative imports
- reference / Relative imports
- request methods / Understanding CRUD operations with Django views and the request methods
- requests / IO, streams, and requests
- creating, for results pagination / Making requests that paginate results
- creating, paginated results used / Making requests that use customized paginated results
- creating, to filter results / Making requests that filter results
- composing, to filter results / Composing requests that filter and order results
- composing, to order results / Composing requests that filter and order results
- creating, to perform starts with searches / Making requests that perform starts with searches
- REST architectural
- resources / RESTful API
- request operations / RESTful API
- error codes / RESTful API
- hypermedia / RESTful API
- RESTful API
- about / RESTful API
- design / API design
- versioning / Versioning
- RESTful system
- client-server / RESTful API
- stateless / RESTful API
- cacheable / RESTful API
- layered system / RESTful API
- code on demand / RESTful API
- uniform interface / RESTful API
- RESTful Web Service
- returned content types / Understanding accepted and returned content types
- return values / Return values
- rich-text editor
- adding, for WYSIWYG editing / Adding a rich-text editor for WYSIWYG editing
S
- scenario tests / Testing your application
- Schwartzian transform / map
- scopes
- search algorithm / What is Sudoku?
- search functionality
- secured API
- browsing, with authentication / Browsing the secured API with the required authentication
- security
- including, to models / Including security and permissions-related data to models
- security checklist / A handy security checklist
- sequence
- iterating over / Iterating over a sequence
- serialization
- service
- Python, running as / Running Python as a service
- service-oriented architecture (SOA) / Inspecting log files
- session hijacking / Why are your cookies valuable?
- set comprehensions / set comprehensions
- set types / Set types
- shell injection
- about / Shell injection
- Django, used / How Django helps
- web attacks / And the web attacks are unending
- shelve
- used, for saving data / Saving data with shelve
- single point of failure (SPOF) / The production environment
- slicing / Indexing and slicing strings, About indexing and slicing
- small values caching / Small values caching
- smoke tests / Testing your application
- solution details, active link
- template-only solution / A template-only solution
- custom tags / Custom tags
- solution details, multiple form actions
- separate views, for separate actions / Separate views for separate actions
- view, for separate actions / Same view for separate actions
- SQL injection
- about / SQL injection
- Django, need for / How Django helps
- Django, avoiding / Where Django might not help
- SQLite
- URL / Analyzing the database
- state attributes, form
- is_bound / Forms in Django
- statistical profiling / Profiling Python
- sticky mode / Using the Python debugger
- Stoplight
- installing / Installing Stoplight
- URL / Installing Stoplight
- streams / IO, streams, and requests
- strings
- about / Strings and bytes
- encoding / Encoding and decoding strings
- decoding / Encoding and decoding strings
- formatting / String formatting
- Structured Query Language (SQL) / Saving data to a database
- superuser
- creating, for Django / Creating the superuser for Django
- supported HTTP OPTIONS requests
- creating, with command-line tools / Making supported HTTP OPTIONS requests with command-line tools
- synchronous scraper / Asynchronous web-scraping
- synchronous web-scraping / Synchronous web-scraping
- Syntactically awesome stylesheets (Sass) / Frontend performance
- system-exiting exceptions / Exceptions
T
- tags / Tags
- template inheritance tree, template patterns
- issue details / Problem details
- solution details / Solution details
- template patterns
- about / Template patterns
- template inheritance tree / Pattern — template inheritance tree
- active link / Pattern — the active link
- templates
- organizing / Organizing templates
- working / How templates work
- temporary directories / Temporary files and directories
- temporary files / Temporary files and directories
- ternary operator / The ternary operator
- test-driven development (TDD)
- about / Test-driven development
- Red phase / Test-driven development
- Green phase / Test-driven development
- Red-Green-Refactor / Test-driven development
- benefits / Test-driven development
- shortcomings / Test-driven development
- testing
- guidelines / Testing guidelines
- tests
- front-end tests / Testing your application
- scenario tests / Testing your application
- integration tests / Testing your application
- smoke tests / Testing your application
- acceptance tests / Testing your application
- user acceptance testing (UAT) / Testing your application
- functional tests / Testing your application
- destructive tests / Testing your application
- performance tests / Testing your application
- usability tests / Testing your application
- penetration tests / Testing your application
- unit tests / Testing your application
- regression tests / Testing your application
- anatomy / The anatomy of a test
- preparation / The anatomy of a test
- execution / The anatomy of a test
- verification / The anatomy of a test
- setup / The anatomy of a test
- teardown / The anatomy of a test
- fixtures / The anatomy of a test
- using, for debug / Using tests to debug
- text/HTML content
- rendering possibility / Understanding the possibility of rendering text/HTML content
- thread
- about / Threads and processes – an overview
- anatomy / Quick anatomy of a thread
- user-level threads / Quick anatomy of a thread
- kernel-level threads / Quick anatomy of a thread
- killing / Killing threads
- context-switching / Context-switching
- global interpreter lock (GIL) / The Global Interpreter Lock
- deadlocks / Race conditions and deadlocks
- race condition / Race conditions and deadlocks, Race conditions
- thread, states
- new thread / Quick anatomy of a thread
- runnable / Quick anatomy of a thread
- running / Quick anatomy of a thread
- not-running / Quick anatomy of a thread
- dead / Quick anatomy of a thread
- threading module
- reference / Dealing with race conditions
- throttling policies
- throttling rules
- advantages / Understanding the importance of throttling rules
- thundering herds / Handling failure
- Timsort / Lists
- Tkinter
- token-based authentication
- working with / Working with token-based authentication
- tokens
- generating / Generating and using tokens
- using / Generating and using tokens
- Tool Command Language (Tcl) / Running Python as a GUI application
- tools
- installing / Installing tools
- Curl, installing / Installing Curl
- HTTPie, installing / Installing HTTPie
- Postman REST client, installing / Installing the Postman REST client
- Stoplight, installing / Installing Stoplight
- iCurlHTTP, installing / Installing iCurlHTTP
- Toy model
- creating / Creating our first model
- traceback
- inspecting / Inspecting the traceback
- triangulation / Test-driven development
- troubleshooting
- guidelines / Troubleshooting guidelines
- console editors, using / Using console editors
- debugging breakpoints, determining / Where to inspect
- tests, using for debug / Using tests to debug
- monitoring / Monitoring
- true division / Integers
- tuples / Tuples
- types, generators
- generator functions / Generators
- generator expressions / Generators
U
- Unicode code points / Strings and bytes
- Uniform Resource Identifiers (URIs) / RESTful API
- unique constraints
- defining / Defining unique constraints
- working with / Working with unique constraints
- unit testing
- with pytest / Getting ready for unit testing with pytest
- unit tests
- about / Testing your application, Unit testing
- writing / Writing a unit test
- writing, for RESTful Web Service / Writing unit tests for a RESTful Web Service
- discovering, with pytest / Discovering and running unit tests with pytest
- executing, with pytest / Discovering and running unit tests with pytest, Running unit tests again with pytest
- writing, to enhance tests code coverage / Writing new unit tests to improve the tests' code coverage
- unpacking / Variable positional arguments
- unsupported HTTP OPTIONS requests
- creating, with command-line tools / Making unsupported HTTP OPTIONS requests with command-line tools
- upcasting / Booleans
- usability tests / Testing your application
- user-based forms, form pattern
- issue details / Problem details
- solution details / Solution details
- user acceptance testing (UAT) / Testing your application
- user information
- UTF-8 encoding / Encoding and decoding strings
V
- variable keyword arguments / Variable keyword arguments
- variable positional arguments / Variable positional arguments
- venv module
- versioning
- versioning, RESTful API
- URI versioning / Versioning
- query string versioning / Versioning
- custom header versioning / Versioning
- media type versioning / Versioning
- versioning classes / Understanding versioning classes
- versioning scheme
- configuring / Configuring a versioning scheme
- vim
- using / Using console editors
- virtualenv
- virtual environment
- creating, with Python 3.x / Creating a virtual environment with Python 3.x and PEP 405
- creating, with PEP 405 / Creating a virtual environment with Python 3.x and PEP 405
- directory structure / Understanding the directory structure for a virtual environment
- activating / Activating the virtual environment
- deactivating / Deactivating the virtual environment
- virtual environment (virtualenv)
- about / About virtualenv
- reference / About virtualenv
- creating / Your first virtual environment
- virtual machines / Virtual machines or Docker
- virtual private server (VPS) / Virtual private servers
W
- web browser
- used, for working with web service / Using a web browser to work with our web service
- WebHook / Endpoint callback pattern
- while loop / The while loop
- white-box tests / Testing your application
Y
- yield from expression / The yield from expression
Z
- zip function / The map, zip, and filter functions, zip