In this section, I would like to introduce you to a few very important concepts, such as scope, names, and namespaces. You can read all about Python's execution model in the official language reference, of course, but I would argue that it is quite technical and abstract, so let me give you a less formal explanation first.
Python's execution model
by Arun Ravindran, Gaston C. Hillar, Fabrizio Romano
Learn Web Development with Python
- Title Page
- Copyright and Credits
- About Packt
- Contributors
- Preface
- A Gentle Introduction to Python
- A proper introduction
- Enter the Python
- About Python
- What are the drawbacks?
- Who is using Python today?
- Setting up the environment
- Installing Python
- How you can run a Python program
- How is Python code organized?
- Python's execution model
- Guidelines on how to write good code
- The Python culture
- A note on IDEs
- Summary
- Built-in Data Types
- Iterating and Making Decisions
- Functions, the Building Blocks of Code
- Why use functions?
- Scopes and name resolution
- Input parameters
- Return values
- A few useful tips
- Recursive functions
- Anonymous functions
- Function attributes
- Built-in functions
- One final example
- Documenting your code
- Importing objects
- Summary
- Saving Time and Memory
- OOP, Decorators, and Iterators
- Decorators
- Object-oriented programming (OOP)
- The simplest Python class
- Class and object namespaces
- Attribute shadowing
- Me, myself, and I – using the self variable
- Initializing an instance
- OOP is about code reuse
- Accessing a base class
- Multiple inheritance
- Class and static methods
- Private methods and name mangling
- The property decorator
- Operator overloading
- Polymorphism – a brief overview
- Data classes
- Writing a custom iterator
- Summary
- Files and Data Persistence
- Working with files and directories
- Data interchange formats
- IO, streams, and requests
- Persisting data on disk
- Summary
- Testing, Profiling, and Dealing with Exceptions
- Concurrent Execution
- Concurrency versus parallelism
- Threads and processes – an overview
- Concurrent execution in Python
- Case examples
- Summary
- Debugging and Troubleshooting
- Installing the Required Software and Tools
- Working with Models, Migrations, Serialization, and Deserialization
- Defining the requirements for our first RESTful Web Service
- Creating our first model
- Running our initial migration
- Analyzing the database
- Controlling, serialization, and deserialization
- Working with the Django shell and diving deeply into serialization and deserialization
- Test your knowledge
- Summary
- Creating API Views
- Using Generalized Behavior from the APIView Class
- Taking advantage of model serializers
- Understanding accepted and returned content types
- Making unsupported HTTP OPTIONS requests with command-line tools
- Understanding decorators that work as wrappers
- Using decorators to enable different parsers and renderers
- Taking advantage of content negotiation classes
- Making supported HTTP OPTIONS requests with command-line tools
- Working with different content types
- Sending HTTP requests with unsupported HTTP verbs
- Test your knowledge
- Summary
- Understanding and Customizing the Browsable API Feature
- Understanding the possibility of rendering text/HTML content
- Using a web browser to work with our web service
- Making HTTP GET requests with the browsable API
- Making HTTP POST requests with the browsable API
- Making HTTP PUT requests with the browsable API
- Making HTTP OPTIONS requests with the browsable API
- Making HTTP DELETE requests with the browsable API
- Test your knowledge
- Summary
- Using Constraints, Filtering, Searching, Ordering, and Pagination
- Browsing the API with resources and relationships
- Defining unique constraints
- Working with unique constraints
- Understanding pagination
- Configuring pagination classes
- Making requests that paginate results
- Working with customized pagination classes
- Making requests that use customized paginated results
- Configuring filter backend classes
- Adding filtering, searching, and ordering
- Working with different types of Django filters
- Making requests that filter results
- Composing requests that filter and order results
- Making requests that perform starts with searches
- Using the browsable API to test pagination, filtering, searching, and ordering
- Test your knowledge
- Summary
- Securing the API with Authentication and Permissions
- Understanding authentication and permissions in Django, the Django REST framework, and RESTful Web Services
- Learning about the authentication classes
- Including security and permissions-related data to models
- Working with object-level permissions via customized permission classes
- Saving information about users that make requests
- Setting permission policies
- Creating the superuser for Django
- Creating a user for Django
- Making authenticated requests
- Making authenticated HTTP PATCH requests with Postman
- Browsing the secured API with the required authentication
- Working with token-based authentication
- Generating and using tokens
- Test your knowledge
- Summary
- Applying Throttling Rules and Versioning Management
- Understanding the importance of throttling rules
- Learning the purpose of the different throttling classes in the Django REST framework
- Configuring throttling policies in the Django REST framework
- Running tests to check that throttling policies work as expected
- Understanding versioning classes
- Configuring a versioning scheme
- Running tests to check that versioning works as expected
- Test your knowledge
- Summary
- Automating Tests
- Solutions
- Chapter 11: Installing the Required Software and Tools
- Chapter 12: Working with Models, Migrations, Serialization, and Deserialization
- Chapter 13: Creating API Views
- Chapter 14: Using Generalized Behavior from the APIView Class
- Chapter 15: Understanding and Customizing the Browsable API Feature
- Chapter 16: Using Constraints, Filtering, Searching, Ordering, and Pagination
- Chapter 17: Securing the API with Authentication and Permissions
- Chapter 18: Applying Throttling Rules and Versioning Management
- Chapter 19: Automating Tests
- Templates
- Admin Interface
- Forms
- Security
- Working Asynchronously
- Creating APIs
- Production-Ready
- Other Books You May Enjoy
Python's execution model
-
No Comment
..................Content has been hidden....................
You can't read the all page of ebook, please click here login for view all page.