Try Django 1.9 | Build a Blog and Learn Python's #1 Library

Learn to build a real blog using Django 1.9 and Python, step by step, covering data storage, user interaction, posting, commenting, and multimedia content.

Walkthrough of building a Django 1.9 blog: create posts, manage drafts, publish dates, upload images, and admin use. Includes search, Facebook sharing, and bootstrap frontend with repository code.

Prepare your system, install Python and Django 1.9, and follow the GitHub guides to copy the project code and set up a blog using Sublime Text.

Explore Django and Python versions, create a virtual environment, and install Django 1.9 to understand version differences, long-term support, and how to run a development server.

Create a Django superuser and access the admin site, while learning migrations and default database setup to store data for the blog app.

Create a django posts app for a blog, build a Post model with title, content, and time stamp, configure admin, and apply migrations with make migrations and migrate.

Explore Django 1.9 admin integration by importing the post model and registering it with the admin site, and review field types like char with max length, date, and datetime.

Explore Django model admin options to customize post displays, including list display, search fields, filters, and editable fields.

Master the CRUD cycle—create, retrieve, update, delete—in Django with admin-driven examples, posts, and views for each operation.

Explore building your first Django view by creating a function-based posts home that displays database content in a simple list view, using render and HttpResponse.

Understand the request and response cycle in Django, seeing how GET requests reach views via URLs and return HTTP responses, including 404s and assets.

Map Django URLs to views by wiring the posts URL to the post_home function, exploring function-based views, imports, and debugging common routing errors.

Learn to structure in-app urls by creating a posts url module, including it in the project, and routing post crud views (create, detail, list, update, delete) under a unified path.

Learn how Django templates let you separate logic from markup, set up a templates directory under the base directory, and configure render to load templates with a file system loader.

Learn how to pass data into templates using a context dictionary, render dynamic pages with title and list or detail data, and use authentication checks to vary content.

Query sets fetch and filter posts from the Django database via the Python managed IPY shell, and expose them to a view as an object list.

Use get_object_or_404 to fetch a post by id or other fields and render its detail view. Pass the retrieved instance to the template as context to display a single post.

Master dynamic url routing and patterns in Django, mapping post ids to queries with regular expressions and passing id as a keyword argument to views.

Learn to create dynamic post links in Django using named URLs, reverse lookups, and get_absolute_url with namespaces for flexible, maintainable routing.

Design and use Django model forms to create posts by rendering a post form with title and content, validating input, and saving to the database through a create view.

Learn to edit posts with a Django instance update view by wiring the post instance, form, and redirects to the post detail after saving.

Implement flash messages with Django's messages framework to notify users after form submissions, displaying success or error notifications in templates with customizable message tags.

Implement a delete view in Django 1.9 to remove a post, redirect to the post list with a success message, and introduce template inheritance.

Explore template inheritance in Django 1.9 by converting repetitive HTML into a base template with blocks, extends, and include, then render dynamic content like post lists and messages.

Set up and test django static files (css, javascript, images) in development, configure a static route and a CDN-like path, run collectstatic, and load assets with the static template tag.

Implement Bootstrap to speed up building a Django blog, using Bootstrap CDN, container and grid classes, templates, line breaks, truncation, and responsive post lists.

Implement pagination in a Django 1.9 blog by ordering posts with a queryset, reversing by timestamp, and wiring a paginate function into the view and template.

Implement file uploads by adding a file field and converting to an image field in Django models, configure media, enable multipart form data, and display uploaded images in posts.

Implement a slug field for blog posts, enforce uniqueness, and auto-generate slugs using a pre-save signal, with a recursive check to ensure each post has a shareable URL.

Create social share links with anchor tags for Facebook, Twitter, and more, enabling two-click sharing, update links to absolute URLs, and url-encode the share text in Django.

Create a custom Django template filter to turn strings into shareable content, register it in the template library, and apply it in post templates for social sharing and content truncation.

Implement basic Django permissions by restricting post creation, updates, and deletions to staff or admin users and raising a 404 for unauthorized access; the author creates and edits articles.

Learn to link a post to a user with a foreign key in Django, set a default admin user, and display the author with get_full_name in templates.

Learn to integrate Facebook comments and like button into a Django blog using the social plug-in and bootstrap layout, with embedding code and authentication considerations.

Learn to add draft and publish date fields to a Django blog model, run migrations, and use model managers and object filters to handle active posts.

Learn how to use Django model managers to filter posts by drafts and publish date, leveraging time zone aware queries and access control for staff.

Develop a simple search filter on the post list using a get query parameter q. Build complex lookups with Django Q to search titles, content, and authors, and preserve pagination.

Discover what you can do with Django 1.9, including live deployment and differences from 1.8. Explore projects at joincfe.com/projects and boost web and mobile app skills with Bootstrap.

Develop a modern, robust blog by advancing the existing project with new features for readers and authors, and learn to share ideas with the world using Django 1.9.

Migrate the Try Django 1.9 blog code into a brand new project by cloning the GitHub repository, setting up a virtual environment, installing requirements, and running the Django server.

Learn how to render HTML and markdown in a Django blog using safe filter and a client-side markdown renderer with JavaScript, jQuery, and the marked library.

Implement the Django page down widget to render stack overflow-style markdown in forms and lists, enabling rich text editing, media, and live markdown previews.

Learn to render responsive images inside Django blog posts by adding a bootstrap image-responsive class to content markdown images with a jQuery tweak, ensuring post detail views display correctly.

Render markdown on the server with django markdown duse and add a post model method get_markdown to convert content, then mark_safe the result for templates to enable previews and rendering.

Explore how to truncate content and manage templates in Django using built-in template tags, including truncate characters and truncate words, with markdown integration.

Update a Django post form with a live preview panel that shows title and markdown content in real time using j query, dynamic content binding, and a markdown renderer.

Install Django crispy forms in your project, configure crispy template pack to bootstrap 3, and use crispy form tags for improved validation and styling.

Learn how to use bootstrap input groups to design a polished search form with input and button addons, apply form-control classes, and incorporate font awesome icons via CDN.

Explore building a comments app with Django generic foreign keys, enabling authenticated users to post comments on blog posts while comparing standard and generic foreign keys.

Convert a post foreign key to a generic foreign key using Django's generic relations, update the comment model, run migrations, and test changes in a local database.

Learn to implement a generic foreign key for comments in a Django blog using content types, object id, and generic relations in views and templates.

Learn how to create a custom model manager to filter by instance, returning a queryset of comments, and render them in a template.

Build a flexible Django blog commenting system by implementing a content type based comment form in the post detail, using hidden fields and get_or_create to store comments.

Build a simple Django blog comment system with a self-referential parent field and one-level replies, using a custom manager to show only top-level comments.

Learn to use jQuery fadeToggle to show or hide comment replies with a click, including a reply button and a comment count.

Create a Django comment thread page that presents a parent comment with its replies, makes the thread shareable, and uses a dedicated thread view with a related form.

Count words and estimate reading time for blog posts in Django using Python, regex, and HTML tag stripping; implement a utility function and store results in the database.

Learn how to implement a blog post read time in Django by adding a read_time field, calculating minutes with a pre save signal receiver, and displaying it in templates.

Learn to implement a delete view with confirmation using get_object_or_404 for comments on a blog post in Django, render a confirmation page, and redirect to the content object after deletion.

Enforce comment delete permissions by checking the comment's owner against request.user and using a delete URL helper, with 404 and 403 responses for unauthorized actions.

Build a basic Django authentication system with login, registration, and logout views using forms and an accounts app to enable user login and blog comments.

Perform basic Django user login form validation using a standard form, authenticate users, verify active status, and implement login and logout flows via the form's clean method.

Learn to build a Django 1.9 user registration flow using a model form tied to the user model, including email confirmation, validation, and setting the password with automatic login.

Apply Django's login_required decorator to protect comments and redirect unauthenticated users to log in with a next parameter, and configure settings to customize login URL and prompts in templates.

Add Bootstrap breadcrumb navigation to a Django blog, including home, posts, login, register, and logout links, and render them conditionally based on user authentication.

continue learning to build full-functioning Django back-end apps from the blog to e-commerce, matchmaker, and digital marketplace projects with step-by-step guidance and future topics.

Learn to build a restful api with the Django rests framework, enabling your blog to connect to other websites and mobile apps using Django 1.9 and the blog project.

Install django 1.9.5 and the rest framework in a virtual environment, set up the blog API, and run migrations to start the server.

Build a Django API with the REST framework by creating a list API view that serves posts as JSON and enables CRUD operations via a dedicated API module and serializer.

Learn to serialize Django models into JSON using a model serializer, specify fields like title, slug, and content, and view serialized data via the browsable API.

Learn how to serialize a Django model in the Python shell with a PostSerializer, inspect object data, and handle required slug during creation.

Learn how to implement a post detail API view to retrieve a single object, using a lookup field with primary key or slug, and customize serializers and ordering.

Create and wire update and destroy API views in a Django REST framework project, mirroring the detailed view and ensuring correct HTTP methods for update (put/patch) and delete operations.

Update and delete a Django model instance from the Python shell using a detail serializer, fetch by id, handle missing objects, and apply data to modify or remove records.

Create a dedicated post create serializer and post create API view to handle new posts, explain using separate serializers, and enforce slug behavior and permissions during create and update.

learn to associate a post with a user in Django REST framework by using perform_create to set the user and retrieve update views for updates.

Implement custom and built-in permissions in a Django Rest Framework app, enforcing authentication and owner-based access, and controlling create, retrieve, and update with safe methods.

Learn to filter a queryset in a ListAPIView using built-in Django filters, search and ordering filters, and Django-filter library, with practical examples for posts and users.

Learn to implement pagination in Django Rest Framework, including limit offset and page number methods, and customize default page size with a custom pagination class.

Learn to implement a hyperlinked identity field in your Django REST framework list API, generating detail URLs, switching to slug lookup, and exposing concise post links.

Learn to use serializer method field to customize serialized output by defining methods like get_user and get_image, exposing username, image urls, and markdown content in list and detail views.

Build a Django comments API by creating serializers and views, establish list and detail endpoints for parent and child comments, and integrate with posts.

Create a child comments serializer and detail serializer to surface replies. Expose the child id and time stamp, and use a serializer method field to fetch replies and count them.

Explore how to include post comments in the Django REST framework post detail serializer using a content type-based generic relations, with options for single or separate calls.

Create and validate a comment create serializer that uses slug and content type to attach comments to posts, handle parent relationships, and ensure slug and model validity.

Learn to implement a generic comment system in Django by building a create by model type method using content type, object id, slug, and pluggable serializer for parent object handling.

Build a comment creation API view in django 1.9, wiring the comment serializer, handling authenticated users, types, slug, and parent id to enable posting and replying to comments.

Enable comment editing in a single API view by adding update and destroy mixins to the comment edit view, using the retrieve API view and a focused serializer.

Refactor the comment detail API to use read-only fields, unify the detail and edit serializers, and enforce owner or read-only permissions for authenticated edits.

Design a Django API for comments with list and detail views, using hyperlinked identity fields, generic foreign keys, and get absolute URLs for posts and comments.

Set up a user API in Django 1.9 by creating a user model, a write-only password serializer, and a register view for signup and login token handling.

Override the ModelSerializer's create method to properly set a user's password from validated data, create the user instance, and save it to the database.

Add and validate a second email field in the serializer, implement emails must match, and enforce unique email to secure user registration.

Build a user login serializer with username, email, and password, include a blank token field initially, and wire it to a base API view using post to authenticate.

Implement user login validation in Django, authenticating by username or email, validating passwords, and returning an authentication token for subsequent requests.

Expose user details in the API by creating a dedicated user detail serializer and nesting it in posts and comments, using read only to safeguard updates and token-based authentication.

Master django rest framework settings by configuring default renderer classes, authentication and permission classes, and per-view permissions to control who can access and interact with your api.

Learn to implement Django REST framework JWT authentication and test it with curl. Discover obtaining tokens, storing them, and using the authorization header to perform authenticated actions like commenting.

Explore how the blog API, powered by Django REST framework, enables you to extend your ecosystem with native apps, maintain and enhance the API, and build future projects.

Learn Django basics to launch web apps quickly, building an nvp landing page to collect emails, implement registration with password-protected pages, and manage data with models, forms, and Bootstrap.

Set up a virtual environment, install django 1.8, and start a new django project to run a local development server and view your first page in the browser.

Run your first Django migration to synchronize apps and database state, using manage.py migrate, and explore built-in migrations since Django 1.7, SQLite databases, and project setup.

Create a Django admin user or superuser, run migrations with manage.py migrate, and log into the admin site to manage data, users, and permissions.

Discover how Django apps provide focused functionality within a project, illustrated by a newsletter app that handles newsletter sign-up while the admin app handles admin tasks.

Run the Django development server, explore the request and response cycle, and build a simple function-based view that renders a template and maps URL patterns for home and admin.

Explore the Django settings overview, detailing the project structure, base directory, secret key, debug mode, and installed apps, plus templates, databases, static files, and internationalization.

Configure django templates by setting dirs and template loaders in settings, manage templates in project or app directories, and troubleshoot by aligning installed apps and template paths.

Create a newsletter model to store sign-up data with email, full name, and a time stamp using date time fields with auto now add; migrate and enable in admin.

Learn to register a sign-up model with the Django admin and customize the admin list display to show unicode, time stamp, and updated fields.

Convert the admin form to a Django model form, define a sign-up form with explicit fields, and control the field order. Import forms, test in admin, and prepare for validators.

Apply custom form validation in Django 1.9 by overriding clean_email to enforce data integrity before saving, using self.cleaned_data, and raising forms.ValidationError for edu address checks.

Learn to render Django forms in views using a template context. Discover how template context variables like title and user drive dynamic content via render, request, and authentication.

Learn to render a Django form in a template. Handle post requests with CSRF token, validate and save form data, and manage context in the view.

Learn to build a pure Django form as a contact form, defining full name, email, and message fields, validating input, rendering in a view, and handling cleaned data.

Configure django to send email via gmail smtp with port 587 and tls; use settings for from, to, and message, and test through a contact form.

Master how Django serves static files, including images, javascript, and css, in development, and configure static routes, static roots, collectstatic, and media handling for production.

Configure and serve Django static and media files in development, with static routes, document roots, and debug mode, and learn to run the server and collect static files.

Learn to add Bootstrap to a Django project, building a mobile-first, responsive front end via CDN or static files, and wire up CSS and JavaScript with Django templates.

Explore the Django templates system, render views with context, and leverage inheritance, blocks, and include to create modular bases, dynamic titles, and reusable nav and content.

Explore how to use the crispy forms third-party package in Django to beautify forms, install and configure it, and render forms with crispy tags using Bootstrap 3.

Master Bootstrap's grid system to craft responsive layouts using container and container-fluid, 12-column rows, and breakpoints with col- classes and media queries.

Style a mvp landing page for the try django series by building a responsive two-column layout with a video placeholder, sign-up link, and bootstrap grid.

Learn how to center text in a Django app by using blocks and a dedicated stylesheet, overriding bootstrap classes with a custom css class, and managing static assets.

Discover how to make internal links in Django using url names instead of hard-coded paths, enabling dynamic, maintainable navigation across home, about, and contact pages.

Style a Django MVP landing page by fixing templates, integrating crispy forms, and centering the contact form with a responsive grid and refined jumbotron.

Master Django registration redux to implement simple user authentication and registration. Configure settings, templates, and activation emails, and test login, password reset, and activation flows.

Update Django login redirect by editing the settings file to set a custom login url. Redirect users to the home page or profile after login.

Learn to implement authentication links in a Django 1.9 blog navbar by using the template context processor and request.user to conditionally show login, register, or logout based on authentication.

Add a login form to the bootstrap navbar. Show it only when the user is not authenticated, with username and password fields, and CSRF protection posting to the login page.

Iterate on the landing page styling by adjusting the jumbotron and container alignment, applying a brand-friendly background and white text, refining the nav bar, and ensuring static assets are collected.

Replace the navbar brand text with a logo image using Django templates and load static. Maintain a 22-pixel height to avoid padding issues and keep branding centered within the navbar.

Embed a video on your site using a YouTube iframe embed code, adjust the height for the landing spot, and explore serving responsive images with Django static files.

Learn to integrate Font Awesome icons into a site via a bootstrap CDN, copy and customize icons, adjust sizes with fa-5x and em units, and create animated, stacked icons.

Clean up the home page styling and navigation, add an about page, and implement admin-only access to signups by using request.user.is_authenticated and is_staff, passing a queryset into the view context.

Master django queryset basics by importing models, retrieving sign-up objects, and iterating over them in templates. Apply filters, order by timestamps, and count results to present data in a table.

Set up django production by creating a base, local, and production settings module, disable debug, and deploy to web faction or heroku with guidance on collect static.

Learn to set up a django project on web faction, create a new application, configure a database and static data, and access the server via ssh using putty.

Learn how to deploy a Django 1.9 blog using ftp and sftp with web factional, configure Apache and wsgi, adjust production settings, databases, and static files for secure production hosting.

Install pip, run migrate, configure static and media routes, and adjust base production settings for a Django 1.9 blog; create a superuser and collect static.

Identify why static files aren't loading, restructure settings to serve static and media separately, run collectstatic, restart the server, and prepare for real-domain deployment and error pages.

Deploy and test a Django blog on your own domain by configuring allowed hosts, setting up error pages (404, 500, 403, 400), and enabling admin alerts for server issues.