Python

1. Introduction to Python Object Types
   1. Conceptual Hierarchy
   2. Why use Built-in Types?
   3. Python’s core Data types
   4. Numbers
   5. Strings

• Sequence Operations
• Immutability
• Type-Specific Methods
• Getting Help
• Other Ways to Code Strings
• Unicode Strings
• Pattern Matching

1. Lists

• Sequence Operations
• Type Specific Operations
• Bound Checking
• Nesting
• Comprehensions

1. Dictionaries
   • Mapping Operations
   • Nesting
   • Missing Keys
   • Soring Keys
   • Iterations & Optimization
2. Tuples

• Why tuples?

• • • Files
    • Other Core Types

2. Numeric Types
3. Basics
4. Numbers in Action
5. Other Numeric Types
   • Decimal
   • Fraction
   • Sets
   • Booleans

1. Numeric Extensions
2. Dynamic Typing

• Missing Declaration Statements
• Shared References
• Dynamic Typing Is Everywhere

4. String Fundamentals
5. String Basics
6. String Literals
   • Single, Double, Triple Quotes
   • Escape Sequences
7. Strings in Action
   • Basic Operations
   • Indexing and Slicing
   • String Conversion Tools
8. String Methods
9. String Formatting Expressions and Methods
10. Lists and Dictionaries
11. Lists
12. Lists in Action
13. Dictionaries
14. Dictionaries in Action

6.Tuples, Files

1. Tuples
2. Tuples in Action
3. Files
   • Opening Files
   • Using Files
   • Files in Action
   • Text and Binary Files
   • Storing Python Objects in Files: Conversions
   • Storing Native Python Objects: pickle
   • Storing Python Objects in JSON Format
   • File Context Mangers
   • Other File Tools
4. Core Types Review & Summary
   • Object Flexibility
   • References vs Copies
   • Comparisons, Equality and Truth
   • Meaning of True and False in Python v. Python Type Hierarchies
   • Type Objects vii. Other Types in Python
   • Built in Type Gotchas

7. Effective Python (Python Best Practices)
8. Pythonic Thinking
9. Lists and Dictionaries

8.Introducing Python Statements

1. Pythons Conceptual Hierarchy
2. Python Statements
3. Why Indentation Syntax?
4. Special Cases
5. Interactive Loops

9.Assignments, Expressions, and Prints

1. Assignments Statements
2. Expression Statements
3. Print Operations

10.If Tests and Syntax Rules

1. If Statements
2. Python Syntax
3. Truth Values and Boolean Tests
4. The if/else Ternary Expression

11.While and for loops

1. While loops
2. Break, continue, pass and the Loop else
3. For loops
4. Loop Coding Techniques

12.Iterations and Comprehensions

1. Iterations
2. List Co11mprehensions
3. Other Iteration Contexts
4. Iterables

• Range
• Map, zip and filter Iterables
• Multiple vs Single Pass Iterators
• Dictionary View Iterables

1. Other Iteration Topics

12.Debugging Python

1. pdb
2. IDE Debugging

13.Documentation

1. Python Documentation Sources

• # Comments
• The dir Function
• DocStrings: __doc__
• PyDoc: The help Function v. PyDoc: HTML Reports
• Beyond docstrings: Sphinx

14.Function Basics

1. Why Use Functions?
2. Coding Functions
3. Definitions & Calls
4. Intersecting Sequences

15.Scopes

1. Python Scope Basics
   • Scope Details
   • Name Resolution: The LEGB Rule
   • Built-in Scope
2. The global Statement
3. Scopes and Nested Functions
4. The nonlocal Statement
5. Why nonlocal?

                                     16.Arguments

1. Argument Passing Basics
2. Special Argument-Matching Modes
3. Generalized Set Functions

17.Advanced Function Topics

1. Function Design Concepts
2. Recursive Functions
3. Function Objects: Attributes and Annotations
4. Anonymous Functions: lambda
5. Functional Programming tools (map, filter and reduce)

18.Comprehensions & Generations

1. List Comprehensions and Functional Tools
2. Generator Functions and Expressions
3. Comprehension Syntax Summary

19.Benchmarking 

1. Timing Iteration Alternatives
2. Timing Iterations and Pythons with timeit
3. Pystones
4. Function Gotchas

20.Effective Python (Python Best Practices)

1. Functions
2. Comprehensions and Generators

21.Modules: The Big Picture

1. Why use modules?
2. Python Program Architecture
3. How Imports Work
4. Byte Code Files: __pycache__
5. Module Search Path

22.Module Coding Basics

1. Module Creation
2. Module Usage
3. Module Namespaces
4. Reloading Modules

23.Module Packages

1. Package Import Basics
2. Why Use Package Imports?
3. Python Relative Imports
4. Namespace Imports

24.Advanced Module Topics

1. Module Design Concepts
2. Data Hiding in Modules
3. Enable Future Language Features: __future__
4. Mixed Usage Modes: __name__ and __main__
5. Changing Module Search Path
6. The as Extension for import and from
7. Importing Modules by Name String

1. Object Oriented Programming: Big Picture
   1. Why Use Classes
   2. OOP high level overview
      • Classes and Instances
      • Method Calls
      • Coding Class Trees
      • Operator Overloading

2. Class Coding Basics

1. Generating Multiple Instance Objects
2. Inheritance
3. Operator Overloading
4. Realistic Example

• Making Instances
• Adding Behavior Methods
• Operator Overloading
• Customizing Behavior by Sub-classing v. Customizing Constructors
  1. Using Introspection tools
• Storing Objects in Database (Pickles and Shelves)

3. Class Coding Details
   1. The class Statement
   2. Methods
   3. Inheritance
   4. Namespaces
   5. Documentation Strings Revisited
   6. Classes vs Modules
4. Designing with Classes
   1. Python and OOP
   2. OOP and Inheritance
   3. OOP and Composition
   4. OOP and Delegation
   5. Multiple Inheritance
5. Advanced Class Topics
   1. Extending Built-in Types
   2. Static and Class Methods
   3. Decorators and Metaclasses
   4. The super Built-in Function
6. Exception Basics
   1. Why Use Exceptions
   2. Exceptions:
      • Default Exception Handler
      • Catching Exceptions
      • Raising Exceptions
      • User-Defined Exceptions v. Termination Actions
   3. Exception Coding Details
      1. The try/except/else Statement
      2. The try/finally Statement
      3. The raise Statement
      4. The assert Statement
      5. With/as Context Managers
   4. Exception Objects
      1. Exception Hierarchies
      2. Built-In Exception Classes
      3. Nesting Exception Handlers
      4. Exception Idioms
      5. Exception Design Tips
   5. Managed Attributes
      1. Why Manage Attributes
      2. Properties
      3. Descriptors
      4. __getattr__ and __getattribute__
   6. Decorators
      1. What’s the Decorator?
      2. Basics
         • Function Decorators
         • Class Decorators
         • Decorator Nesting
         • Decorator Arguments
         • Decorators Manage Functions and Classes, Too
      3. Coding Function Decorators
      4. Coding Class Decorators
      5. Managing Functions and Classes Directly
   7. Metaclasses
      1. Metaclass Model
      2. Declaring Metaclasses
      3. Coding Metaclasses
      4. Metaclass vs Superclass
      5. Metaclass Methods
   8. Logging and Tracing
      1. Logger Objects
      2. Logger Levels
      3. Formatter
      4. Filter Objects
      5. Log Record Objects and Attributes
      6. Logger Adapter Objects
   9. Concurrency
      1. Starting and Stopping Threads
      2. Thread Communications
      3. Locking Critical Sections
      4. Locking with Deadlock Avoidance
      5. Storing Thread Specific State
      6. Creating a Thread Pool
      7. Performing a d Simple Parallel Programming
      8. Dealing with GIL
      9. Defining an Actor Task
      10. Implementing Publish/Subscribe Messaging
      11. Polling Multiple Thread Queues

1. Getting Started
2. Introducing Django
   • Installing Django
   • Installing a Python Virtual Environment
   • Setting up a database
   • Starting a project
   • The Model-View-Controller design pattern
3. Views and URLconfs
4. Sample Django-Powered Page: Hello World
   • Your first view
   • Your first URLconf
   • Regular expressions
   • A quick note about 404 errors
   • A quick note about the site root
   • How Django processes a request
5. Dynamic Content
6. Dynamic URLs
7. Django’s pretty error pages

3. Templates
   1. Template System Basics
   2. Using the template system
   3. Dictionaries and contexts
   4. Basic template-tags and filters
   5. Philosophies and limitations
   6. Using templates in views
   7. Template loading
   8. render()
   9. Template subdirectories
   10. The include template tag

k.Template inheritance

4. Models
   1. The “dumb” way to do database queries in views
   2. Configuring the database
   3. Your first app
   4. Defining Models in Python
   5. Basic data access
5. The Django Admin Site
6. Using the admin site
   • Start the development server
   • Enter the admin site
7. Adding your models to the admin site
8. Making fields optional
9. Customizing field labels
10. Custom model admin classes
11. Users, groups, and permissions
12. When and why to use the admin interface-and when not to

6. Forms
   1. Getting data from the Request Object
      • Information about the URL
      • Other information about the Request
      • Information about submitted data
   2. A simple form-handling example
   3. Query string parameters
   4. Improving our simple form-handling example
   5. Simple validation
   6. Making a contact form
   7. Tying form objects into views
   8. Changing how fields are rendered
   9. Setting a maximum length
   10. Setting initial values
   11. Custom validation rules
   12. Specifying labels
   13. Customizing form design
7. Advanced Views and URL confs
   1. URLconf Tips and Tricks
      • Streamlining function imports
      • Special-Casing URLs in debug mode
      • Named groups Preview

1. The matching/grouping algorithm iv. What the URLconf searches against

• Captured arguments are always strings
• Specifying defaults for view arguments

1. Performance
2. Error handling
3. Including other URLconfs
4. Captured parameters
5. Passing extra options to view functions
6. Passing extra options to include()
7. Reverse resolution of URLs
8. Naming URL patterns
9. URL namespaces
10. Reversing namespaced URLs
11. URL namespaces and included URLconfs

8. Advanced Templates
   1. Template language review
   2. Requestcontext and context processors
      • auth
      • DEBUG
      • i18n
      • MEDIA
      • static
      • csrf
      • Request
      • messages
   3. Guidelines for writing our own context processors
   4. Automatic HTML escaping
      • How to turn it off
      • For individual variables
      • For template blocks

iv.Automatic escaping of string literals in filter arguments

1. Inside Template loading
   • The DIRS option
   • Loader types
     1. Filesystem loader
     2. App directories loader
     3. Other loaders

1. Extending the template system
   • Code layout
   • Creating a template library
2. Custom template tags and filters
3. Writing custom template filters
   1. Registering custom filters
   2. Template filters that expect strings
   3. Filters and auto-escaping
   4. Filters and time zones ii. Writing custom template tags
   5. Simple tags
   6. Inclusion tags
   7. Assignment tags
4. Advanced custom template tags
   • A quick overview
   • Writing the compilation function
   • Writing the renderer
   • Auto-escaping Considerations v. Thread-safety Considerations
   • Registering the tag
   • Passing template variables to The Tag
   • Setting a variable in the context
   • Variable scope in context
   • Parsing until another block tag
   • Parsing until another block tag, and saving contents
5. Advanced Models
   1. Related objects
      • Accessing ForeignKey values
      • Accessing many-to-many values
   2. Managers
      • Adding extra manager methods
      • Modifying initial manager QuerySets
   3. Model methods

• Overriding predefined model methods

1. Executing raw SQL queries
2. Performing raw queries

• • • • Model table names
      • Mapping query fields to model fields
      • Index lookups
      • Deferring model fields v. Adding annotations

• Passing parameters into raw()

1. Executing custom SQL directly
   • Connections and cursors
   • Adding extra Manager methods
2. Generic Views
   1. Generic views of objects
   2. Making “friendly” template contexts
   3. Adding extra context
   4. Viewing subsets of objects
   5. Dynamic filtering
   6. Performing extra work
3. User Authentication in Django
4. Overview
5. Using the Django authentication system
6. User objects
   • Creating superusers
   • Creating users
   • Changing passwords
7. Permissions and authorization
   • Default permissions
   • Groups
   • Programmatically creating permissions
   • Permission caching
8. Authentication in web requests
   • How to log a user in
   • How to log a user out
   • Limiting access to logged-in users
     1. The raw way
     2. The login_required decorator
     3. Limiting access to logged-in users that pass a test
     4. The permission_required() decorator
     5. Session invalidation on password change

1. Authentication views

• Login
• Logout
• Logout_then_login iv. Password_change
• Password_change_done
• Password_reset
• Password_reset_done
• Password_reset_confirm
• Password_reset_complete
• The redirect_to_login helper function
• Built-in forms

1. Authenticating data in templates
   • Users
   • Permissions
2. Managing users in the admin
   • Creating users
   • Changing passwords
3. Password management in Django
   • How Django stores passwords
   • Using Bcrypt with Django
   • Password upgrading
   • Manually managing a user’s password
4. Customizing authentication in Django

• Other authentication sources
• Specifying authentication backends
• Writing an authentication backend
• Handling authorization in custom backends v. Authorization for anonymous users
• Authorization for inactive users
• Handling object permissions

1. Custom permissions
2. Extending the existing user model
3. Substituting a custom user model
4. Testing in Django
   1. Introduction to testing
   2. Introducing automated testing
      • What are automated tests?
      • So why create tests?
   3. Basic testing strategies
   4. Writing a test
   5. Creating a test
   6. Running tests
   7. Testing Tools
   8. The test database
   9. Using different testing frameworks
5. Deploying Django
   1. Preparing your codebase for production
   2. Critical settings
   3. Environment-specific settings
   4. HTTPS
      • CSRF_COOKIE_SECURE
      • SESSION_COOKIE_SECURE
   5. Performance optimizations
   6. Error reporting
      • LOGGING
      • ADMINS and MANAGERS
      • Customize the default error views
   7. Using a virtualenv
   8. Using different settings for production
   9. Deploying Django to a production server
   10. Deploying Django with Apache and mod_wsgi
   11. Serving static files in production
   12. Scaling
       • Running on a single server
       • Separating out the database server
       • Running a separate media server
       • Implementing load balancing and redundancy v. Going big
   13. Performance tuning
6. Generating Non-Html Content
   1. The basics: views and MIME types
   2. Producing CSV
   3. Using the template system
   4. Other text-based formats
   5. Generating PDF
   6. Install ReportLab
   7. Write your view
   8. Complex PDF’s
   9. Other possibilities
   10. The syndication feed framework
   11. The Sitemap framework
7. Django Sessions
   1. Enabling sessions
   2. Configuring the session engine
   3. Using Sessions in Views
   4. flush()
   5. Session object guidelines
   6. Session serialization
   7. Setting test cookies
   8. Using sessions out of views
   9. When sessions are saved
   10. Browser-length sessions vs. persistent sessions
   11. Clearing the session store
8. Django Cache Framework
   1. Setting up the cache
      • Memcached
      • Database caching
      • Filesystem caching iv. Local-memory caching
      • Dummy caching (for development)
      • Using a custom cache backend
      • Cache arguments
   2. The per-site cache
   3. The per-view cache
   4. Template fragment caching
   5. The low-level cache API
   6. Downstream caches
   7. Using vary headers
   8. Controlling cache: using other headers
9. Django Middleware
   1. Activating middleware
   2. Hooks and application order
   3. Writing your own middleware
   4. Available middleware
   5. Middleware ordering
10. Security in Django
11. Django’s built in security features
    • Cross Site Scripting (XSS) protection
    • Cross Site Request Forgery (CSRF) protection
12. SOL injection protection
13. Clickjacking protection
14. SSL/HTTPS
15. Host header validation
16. Session security
17. Additional Security tips

19. Sample Site Building on Django