DEV Community: victor wangari

PYTHON FLASK

victor wangari — Tue, 18 Jun 2024 12:09:48 +0000

*What is flask *
Flask is micro web framework written in python.
It is designed to be lightweight and easy to use, providing the essential tools needed to build web applications, while allowing developers the flexibility to add additional libraries and tools as required.

Key Features of Flask
1.Simplicity and flexibility:Flask is simple to set up and use. It gives developers the freedom to choose the components they want to use, making it flexible for a wide range of applications.

2.Lightweight:As a micro-framework, Flask comes with a small core and essential functionalities. Additional features can be added using extensions.

3.Modular Design:Flask's modular design allows for the inclusion of extensions for added functionality, such as database integration, form validation, and authentication.

4.Built-in Development Server and Debugger: Flask includes a built-in development server and a debugger, which help developers test and debug their applications.

5.Jinja2 Templating: Flask uses Jinja2 templating engine, which enables developers to use templates to dynamically generate HTML.

6.RESTful Request Dispatching:Flask supports RESTful request dispatching, making it a good choice for developing APIs.

7.WSGI Compliance:Flask is WSGI compliant, which means it can be deployed on any WSGI-compatible web server.

Common Extensions used in flask
Flask does not come with many built-in features but relies on extensions to provide additional functionality. Some popular Flask extensions include:
.Flask-SQLAlchemy:Adds SQLAlchemy support for the database operations.
Flask-WTF:Integrates WTForms for form handling and validations.
Flask-Login:Manages users session and authentication.
Flask-Migrate:Handles database migrations using Alembic.

to be continued....

PYTHON P-3 PROJECT

victor wangari — Mon, 10 Jun 2024 17:52:15 +0000

==>Creating a URL shortener is a great project that leverages databases, ORMs, and database diagrams effectively. Here’s how you can approach building a URL shortener using Python with SQLite3 and SQLAlchemy.

Project: URL Shortener
Features

Shorten URLs
- Accept long URLs and generate short URLs
- Ensure unique short URLs -Optionally, allow custom short URLs

2.Redirect Short URLs
-Redirect users to the original URL when
they visit the short URL

3.URL Analytics
-Track the number of visits to each short
URL.

4.User Management(OPTIONAL)
-Allow users to register and manage their
short URLs .
-Implement user authentication(login/logout)

5.Database Diagram
-Visual representation of the database
schema using tools like dbdiagram.io or
SQLAlchemy's build-in features

Steps to Implement
1.Setup the Project

-Create a new directory for your project
-Set up a virtual environment
-Install necessary dependencies: flask,
** sqlalchemy*, **flask_sqlalchemy,
**flask_migrate*

2.Database Design

-Define the database schema using SQLAlchemy
models
-Create tables for URLs and Users (if user
management is implemented)

3.Database Diagram

-Use a tool like dbdiagram.io to create a
visual representation of your database
schema
-Alternatively, use SQLAlchemy to generate
the schema and visualize it using a library
like ERAlchemy

4.URL Shortening Logic

-Implement logic to generate short URLs
-Handle URL collisions to ensure unique short
URLs

5.Redirect Logic__

-Implement route to handle redirection from
short URLs to original URLs

6.Analytics

-Track and store analytics data such as
visit counts and access dates

7.User Management (Optional)

-Implement user registration and login using
Flask-Login or Flask-Security
-Allow users to manage their short URLs

8.Testing and Deployment

-Write unit tests for your application
-Deploy the application using a service like
Heroku or AWS

SQL JOIN IN PYTHON

victor wangari — Sat, 08 Jun 2024 18:43:48 +0000

In SQL, the JOIN clause is used to combine rows from two or more tables based on a related column between them.

Types of JOINs
1. INNER JOIN
An **INNER JOIN returns only the rows that have matching values in both tables.
SYNTAX

SELECT columns
FROM table1
INNER JOIN table2
ON table1.common_column = table2.common_column;

 _EXAMPLE_

SELECT employees.name, departments.department_name
FROM employees
INNER JOIN departments
ON employees.department_id = departments.id

EXPLANATIONS
**This query selects all employees and their corresponding department names where there is a match between employees.department_id and departments.id.

2. LEFT JOIN (or LEFT OUTER JOIN)
**A LEFT JOIN returns all rows from the left table (table1), and the matched rows from the right table (table2). If no match is found, NULL values are returned for columns from the right table.

_SYNTAX_

SELECT columns
FROM table1
LEFT JOIN table2
ON table1.common_column = table2.common_column;

_EXAMPLE_

SELECT employees.name, departments.department_name
FROM employees
LEFT JOIN departments
ON employees.department_id = departments.id;

EXPLANATIONS

**This query selects all employees, including those who do not belong to any department. For employees without a department, department_name will be NULL.

3.RIGHT JOIN (or RIGHT OUTER JOIN)

**A RIGHT JOIN returns all rows from the right table (table2), and the matched rows from the left table (table1). If no match is found , NULL values are returned for columns from the left table.

_SYNTAX_

SELECT columns
FROM table1
RIGHT JOIN table2
ON table1.common_column = table2.common_column;

EXAMPLE

SELECT employees.name, departments.department_name
FROM employees
RIGHT JOIN departments
ON employees.department_id = departments.id;

_EXPLANATIONS_

**This query selects all departments, including those without any employees. For departments without employees, name will be NULL.

4.FULL JOIN (or FULL OUTER JOIN)

**A FULL JOIN returns all rows when there is a match in either left (table1) or right (table2) table. Rows without a match in one of the tables will have NULLs for columns from that table.

SYNTAX

SELECT columns
FROM table1
FULL JOIN table2
ON table1.common_column = table2.common_column;

EXAMPLE

SELECT employees.name, departments.department_name
FROM employees
FULL JOIN departments
ON employees.department_id = departments.id;

_EXPLANATIONS_

This query selects all employees and departments, showing NULLs where there is no match.

5.CROSS JOIN
**A CROSS JOIN returns the Cartesian product of the two tables, i.e., it returns all possible combinations of rows from the tables.

_SYNTAX_

SELECT columns
FROM table1
CROSS JOIN table2;

_EXAMPLE_

SELECT employees.name, departments.department_name
FROM employees
CROSS JOIN departments;

EXPLANATIONS
**This query combines each employee with each department, resulting in a large number of rows.

6.SELF JOIN
**A SELF JOIN is a regular join, but the table is joined with itself.

SYNTAX

SELECT a.columns, b.columns
FROM table a, table b
WHERE a.common_column = b.common_column;

EXAMPLE

SELECT e1.name AS Employee, e2.name AS Manager
FROM employees e1
INNER JOIN employees e2
ON e1.manager_id = e2.id;

Key Points:
i. JOIN Conditions:The ON clause specifies the condition for the join, typically matching a column from one table with a column from another table.
ii. Aliases:Using table aliases (e.g., e1, e2 in the SELF JOIN example) can make the query more readable and manageable, especially for self joins or when the same table is used multiple times.
iii. NULL Handling:In OUTER JOINs (LEFT, RIGHT, FULL), unmatched rows will have NULL values for the columns of the table that does not have the match.

OBJECT-RELATIONAL MAPPING in PYTHON

victor wangari — Thu, 06 Jun 2024 09:43:57 +0000

KEY VOCAB
Object-Relational Mapping(ORM): A technique used to convert database records into objects in an object-oriented language.

INTRODUCTION
**Object Relational Mapping is way for our python programs to manage database data by "mapping" database tables to classes and instances of classes to rows in those tables.
**There is no special programming magic to an ORM — it is simply a manner in which we implement the code that connects our Python program to our database. For example, you can use code like this to connect your Python program to a given database:

*db_connection = sqlite3.connect('db/my_database.db')
db_cursor = db_connection.cursor()
*
An ORM is really just a concept. It is a design pattern , a conventional way for us to organize our program when we want those programs to connect to a database.The conventional is this :
When "mapping" our program to a database, we equate classes with database tables, and instances of those classes with table rows.

WHY USE ORM??
.Cutting down repetitive code.
.Implementing conventional patterns that are organized and sensical

Cutting Down on Repetition
As programmers , you might remember we are lazy.We don't like to repeat ourselves if we can avoid it. Repetition qualifies as a "code smell". Instead of repeating the same, or similar, code any time we want to perform common actions against our database, we can write a series of methods to abstract that behavior.
** We can use **save() method on our classes that handles the common actions if INSERTing data into database.

LOGICAL DESIGN
**Another important reason to implement the ORM pattern is that it just makes sense. Telling our Python program to communicate with our database is confusing enough without each individual developer having to make their own, individual decision about how our program should talk to our database.

Instead, we follow the convention: classes are mapped to or equated with tables and instances of a class are equated to table rows.

If we have a Cat class, we have a cats table. Cat instances get stored as rows in the cats table.

Further, we don't have to make our own potentially confusing or non-sensical decision about what kinds of methods we will build to help our classes communicate with our database. Just like the save() method we previewed above, we will learn to build a series of common, conventional methods that our programs can rely on again and again to communicate with our database.