DEV Community: It's pronounced W3SHY

Why ViTest is a Powerful Testing Framework for TypeScript Projects

It's pronounced W3SHY — Fri, 30 Jun 2023 17:58:24 +0000

Introduction

Testing is a crucial part of the software development process, ensuring the reliability and stability of your codebase. When it comes to testing JavaScript and TypeScript applications, there are several popular testing frameworks available. One such framework that deserves attention is ViTest. In this article, we will explore why ViTest stands out as a powerful testing framework for TypeScript projects, offering unique advantages over other frameworks like Jest.

Note that in this article we're not going to dive into the installation, setup and configurations. Let's get into it.

1. Minimal Setup and Configuration

ViTest simplifies the setup and configuration process, allowing developers to focus more on writing tests and less on tedious configuration. It provides a minimalistic approach, making it ideal for small to medium-sized projects.

2. Concise and Readable Syntax:

ViTest provides a concise and readable syntax, making it easier to write and understand test cases. With its clean and intuitive API, you can express your test expectations in a natural language-like manner. Let's compare a basic test case written in ViTest and Jest:

// ViTest Example
import { test, expect } from 'vitest';

test('sum function should return the correct result', () => {
  const result = sum(2, 3);
  expect(result).toBe(5);
});

// Jest Example
import { sum } from './math';

test('sum function should return the correct result', () => {
  const result = sum(2, 3);
  expect(result).toBe(5);
});

As you can see, ViTest's syntax is clean and straightforward, focusing on the essential aspects of the test. This simplicity leads to more readable and maintainable test code.

3. TypeScript Integration:

ViTest seamlessly integrates with TypeScript, taking full advantage of its type system to catch errors and provide helpful feedback during testing. You can define and enforce type validations within your test cases, ensuring type correctness throughout your testing process. Here's an example:

// ViTest Example
import { test, expect } from 'vitest';

interface Person {
  name: string;
  age: number;
}

test('should validate the type of a person object', () => {
  const person: Person = { name: 'John', age: 30 };
  expect(person.name).toBeType('string');
  expect(person.age).toBeType('number');
});

// Jest Example
import { Person } from './types';

test('should validate the type of a person object', () => {
  const person: Person = { name: 'John', age: 30 };
  expect(typeof person.name).toBe('string');
  expect(typeof person.age).toBe('number');
});

By leveraging TypeScript's type checking capabilities, ViTest helps catch potential type-related issues early on, making your tests more robust and reliable.

4. Performance and Test Execution Speed:

ViTest is known for its excellent performance and fast test execution speed. It optimizes test execution, ensuring your test suite runs efficiently, even as your codebase grows. This advantage becomes especially significant when dealing with large-scale projects or running extensive test suites.

My Final Thoughts

When it comes to testing TypeScript projects, ViTest offers a compelling alternative to other popular testing frameworks like Jest. With its concise syntax, TypeScript integration, and impressive performance, ViTest empowers developers to write clean, readable, and efficient tests. Consider giving ViTest a try for your next TypeScript project and experience the benefits it brings to your testing workflow.

Remember, testing is a critical aspect of software development, and choosing the right testing framework can significantly impact your project's success. Embrace ViTest and unlock its power for comprehensive and reliable testing in your TypeScript applications.

Conclusion

I hope you found the information helpful and informative! If you have any comments or feedback on the article, please feel free to leave them below. I'd love to hear your thoughts and insights on the topic.

In addition, you can connect with me on Linkedin and follow me on Twitter, I regularly share what I am learning and resources on how improve and skill up.

Happy testing with ViTest!

REST APIs with Django Djoser

It's pronounced W3SHY — Thu, 16 Feb 2023 18:26:08 +0000

Introduction

An API(Application Programming Interface), is a set of protocols and methods that allow software applications to communicate with each other. An API specifies how software components should interact with each other, providing a means of communication between different applications or systems.

A REST API is a type of web API that follows a specific set of architectural principles and constraints to enable communication between software applications.

Django Djoser

Django Djoser is a Django package that provides a set of API endpoints and views for handling user authentication and registration. It simplifies the process of building a user authentication system in Django by providing a set of pre-built views and API endpoints for common authentication use cases, such as user registration, email verification, password reset, and more.

Lets Get started

To get started with Django Djoser, you'll need to install it using pip:
pip install djoser.

Once installed, you can add Djoser to your Django project by adding it to your INSTALLED_APPS setting in your settings.py file:

INSTALLED_APPS = [
    # ...
    'djoser',
    # ...
]

Djoser provides a set of API endpoints and views that you can use to handle common user authentication tasks. Here's an overview of some of the most commonly used endpoints:

/auth/users/: This endpoint is used for user registration. It expects a POST request with a JSON payload containing the new user's username, email, and password. Once the user is created, a verification email is sent to the user's email address.

/auth/users/confirm/: This endpoint is used to confirm a user's email address after registration. It expects a POST request with a JSON payload containing the user's email and the verification code sent in the verification email.

/auth/token/login/: This endpoint is used for user login. It expects a POST request with a JSON payload containing the user's username and password. If the credentials are valid, it returns an access token and a refresh token.

/auth/token/refresh/: This endpoint is used to refresh an access token. It expects a POST request with a JSON payload containing the refresh token. If the refresh token is valid, it returns a new access token.

/auth/password/reset/: This endpoint is used to initiate a password reset request. It expects a POST request with a JSON payload containing the user's email. If the email address is associated with a user account, a password reset email is sent to the user's email address.

/auth/password/reset/confirm/: This endpoint is used to confirm a password reset request. It expects a POST request with a JSON payload containing the user's email, the reset token sent in the password reset email, and the new password.

from django.urls import path, include
from djoser.views import (
    UserCreateView,
    UserActivateView,
    TokenCreateView,
    TokenRefreshView,
    PasswordResetView,
    PasswordResetConfirmView,
)

urlpatterns = [
    # ...
    path('auth/', include('djoser.urls')),
    path('auth/', include('djoser.urls.authtoken')),
    # ...
]

This will add all the default Djoser URL patterns to your project, including the ones for the endpoints listed above.

Conclusion

In conclusion, Django Djoser is a powerful and flexible authentication package for Django that can save you a lot of time and effort when building a user authentication system. It provides a set of pre-built views and API endpoints for handling common authentication tasks, and is easy to integrate into your existing Django project. Whether you're building a simple web application or a complex enterprise-level system, Djoser can help you get up and running quickly and easily.

Resources

You can get more information on the Djoser Documentation.
Also, I'll be following up with another article that we'll create an application and use Djoser practically.

Connect With Me

Thank you for taking the time to read this article on Django Djoser. I hope you found the information helpful and informative! If you have any comments or feedback on the article, please feel free to leave them below. I'd love to hear your thoughts and insights on the topic.

In addition, you can connect with me on Linkedin and follow me on Twitter, I regularly share what I am learning and resources on how improve and skill up on Django.

Happy Coding!

The difference on AbstractUser and AbstractBaseUser

It's pronounced W3SHY — Wed, 05 Oct 2022 09:34:17 +0000

Introduction

It is important to understand the difference between AbstractUser and AbstractBaseUser when you are a Django developer. I am hoping that this article will help you answer the confusions the two come with.

First, we explain…

AbstractUser

AbstractUser class initially has 11 fields, the same as default "User" class as shown below and for the subclass of AbstractUser class, you can add new fields, change and remove initial fields.

Keep it in mind that "username" and "email" fields in the initial fields of AbstractUser class are special and only "username" fields have Unique Constraint.
These are the initial fields of AbstractUser class which default "User" class has as shown below:

id 
password 
last_login 
is_superuser 
username (Special, Unique Constraint) 
first_name 
last_name 
email (Special) 
is_staff 
is_active 
date_joined

AbstractBaseUser

AbstractBaseUser class initially has 3 fields as shown below and for the subclass of AbstractBaseUser class, you can add new fields, change and remove initial fields the same as AbstractUser class.

These are the initial fields of AbstractBaseUser class as shown below:

id 
password 
last_login

From what we have seen...

AbstractUser is a full User model, complete with fields which you’re probably already used to. It's an abstract class so that you can inherit from it and add your own profile fields required for your database and methods. It’s a change of schema of the database. The fields you might add are like date_of_birth, location to the User model which means you will get the complete field which was there by default plus your added fields.

from django.db import models
from django.contrib.auth.models import AbstractUser

# TODO: First you import the AbstractUser from django auth model 
#  and inherit it with the Custom User model

# Create your models here
class CustomUser(AbstractUser):
    date_of_birth = models.DateTimeField()
    location = models.CharField(max_length=100)
    nickname = models.CharField(max_length=100)

The above example you will get all the fields of the User model, additionally the fields that we defined here: date_of_birth, location & nickname.

AbstractBaseUser only contains the authentication functionality: you have to supply them when you subclass. It makes fewer assumptions.
- You have to tell it what field will represent the username, the fields that are required, and how those users will be managed.

from django.db import models
from django.contrib.auth.models import AbstractBaseUser

# TODO: First you import the AbstractBaseUser from django auth model 
#  and inherit it with the Custom User model

# Create your models here
class CustomUser(AbstractBaseUser):
    email = models.EmailField(max_length=256, unique=True, verbose_name='email')
    date_of_birth = models.DateTimeField()
    location = models.CharField(max_length=100)
    is_active = models.BooleanField(default=True)
    is_admin = models.BooleanField(default=False)

    USERNAME_FIELD = 'email'
    REQUIRED_FIELDS = 'location'

Keep it in mind that as you've already noticed, AbstractBaseUser class also has "USERNAME_FIELD" and by default, no field is set to "USERNAME_FIELD" so you need to set one existing field to it as shown above otherwise there is an error. In addition, no fields are set to "REQUIRED_FIELDS"

It is important to note that you can also set email as your unique identifier by using AbstractUser, this can be done by setting username = None and USERNAME_FIELD = 'email' as shown below

from django.db import models
from django.contrib.auth.models import AbstractUser

# TODO: First you import the AbstractUser from django auth model 
#  and inherit it with the Custom User model

# Create your models here
class CustomUser(AbstractUser):
    username = None
    email = models.EmailField(max_length=256, unique=True, verbose_name='email')

    USERNAME_FIELD = 'email'
    REQUIRED_FIELDS = 'location'

    def __str__(self):
        return self.email

In Conclusion, which one should you use?

Main difference basically lies on Use-case. Say for example you no longer need the existing User class provided by Django and you only care about authentication functionalities provided by the User class and your own custom fields. In that case, you should use AbstractBaseUser. In another case, you want to use existing User Fields and functionalities but on top of that you would like to add some extra fields and methods. In that case, you should use AbstractUser.

For feedback, reach out on Twitter

How to Deploy Django Applications on Heroku

It's pronounced W3SHY — Thu, 19 May 2022 18:23:36 +0000

Install Heroku CLI

After installing the Heroku CLI, open a terminal and login to your account:

$ heroku login
heroku: Press any key to open up the browser to login or q to exit: 
heroku: Waiting for login... ⣻

You're redirected to your browser and you login to Heroku with Heroku CLI and get a success message on your terminal

Creating App

First make sure you are in the root directory of the repository you want to deploy

Next create the heroku app from the terminal:

heroku create <your-app>

Preparing the Application

Assumptions

You're familiar with the basics of Django. eg. concept of apps, settings, urls, basics of databases.
You have a Django application that you want to deploy to Heroku.
You are familiar with virtual environments
Your deployment Database is PostgreSQL

You will have to install several packages that will come in handy:

django-heroku pip install django-heroku
gunicorn pip install gunicorn
decouple pip install python-decouple
DATABASE_URL pip install dj-database-url
whitenoise pip install whitenoise

You will then add the following files in your application

Add a Procfile in the project root;
Add requirements.txt file with all the requirements in the project root;
Add requirements.txt with pip freeze > requirements.txt
A runtime.txt to specify the correct Python version in the project root;
Configure whitenoise to serve static files.

Now we go through each one of them

Procfile

Heroku apps include a Procfile that specifies the commands that are executed by the app’s dynos.
Create a file named Procfile in the project root with the following content:

web: gunicorn your_project_name.wsgi

runtime.txt

This file contains the python version you are using for heroku to use, create runtime.txt in your project root and add your python version in the following format:

python-3.8.12

You can specify which runtime to use for your app. List of Heroku Runtimes

Configuring Whitenoise: Django Static Files settings

It turns out django does not support serving static files in production. However, WhiteNoise project can integrate into your Django application, and was designed with exactly this purpose in mind.

Lets first configure static related parameter in settings.py

BASE_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))

# Static files (CSS, JavaScript, Images)
# https://docs.djangoproject.com/en/1.9/howto/static-files/

STATIC_ROOT = os.path.join(BASE_DIR, 'staticfiles')
STATIC_URL = '/static/'

# Extra places for collectstatic to find static files.
STATICFILES_DIRS = (
    os.path.join(BASE_DIR, 'static'),
)

Then add this line of code in the middleware section

MIDDLEWARE_CLASSES = (
    # Simplified static file serving.
    # https://warehouse.python.org/project/whitenoise/
    'whitenoise.middleware.WhiteNoiseMiddleware',
    ...

Add the following setting to settings.py in the static files section to enable gzip functionality.

# Simplified static file serving.
# https://warehouse.python.org/project/whitenoise/

STATICFILES_STORAGE = 'whitenoise.storage.CompressedManifestStaticFilesStorage'

# configuring the location for media
MEDIA_URL = '/media/'
MEDIA_ROOT = os.path.join(BASE_DIR, 'media')

# Configure Django App for Heroku.
django_heroku.settings(locals())

python-decouple and dj-database-url

Python Decouple is a must have app if you are developing with Django. It’s important to keep your application credentials like API Keys, tokens and passwords.
dj-database-url is a simple Django utility that holds your Postgres database url

.env

Firts create a .env file and add it to .gitignoreso you don’t commit any sensitive data to your repository. Below is an example of configurations you can add to the .env file.

# An example, don't share your.env settings
SECRET_KEY='342s(s(!hsjd998sde8$=o4$3m!(o+kce2^97kp6#ujhi'
DEBUG=True
DB_NAME='db_name'
DB_USER='user'
DB_PASSWORD='db_password'
DB_HOST='127.0.0.1'
MODE='dev'
ALLOWED_HOSTS='<app name in heroku>.herokuapp.com'
DISABLE_COLLECTSTATIC=1

We then edit settings.py to enable decouple to use the .env configurations.

import os
import django_heroku
import dj_database_url
from decouple import config,Csv

MODE=config("MODE", default="dev")
SECRET_KEY = config('SECRET_KEY')
DEBUG = config('DEBUG', default=False, cast=bool)
# development
if config('MODE')=="dev":
   DATABASES = {
       'default': {
           'ENGINE': 'django.db.backends.postgresql_psycopg2',
           'NAME': config('DB_NAME'),
           'USER': config('DB_USER'),
           'PASSWORD': config('DB_PASSWORD'),
           'HOST': config('DB_HOST'),
           'PORT': '',
       }

   }
# production
else:
   DATABASES = {
       'default': dj_database_url.config(
           default=config('DATABASE_URL')
       )
   }

db_from_env = dj_database_url.config(conn_max_age=500)
DATABASES['default'].update(db_from_env)

ALLOWED_HOSTS = config('ALLOWED_HOSTS', cast=Csv())

Deploying the app to Heroku

Create a postgres addon to your Heroku app

heroku addons:create heroku-postgresql:hobby-dev

Next we log in to Heroku dashboard to access our app and configure it

Add all your configurations in .env file directly to Heroku by running this command.

heroku config:set $(cat .env | sed '/^$/d; /#[[:print:]]*$/d')

Remember to first set DEBUG to False and confirm that you have added all the configuration variables needed. Click on the Settings menu and then on the button Reveal Config Vars

Pushing to Heroku

Confirm that your app is running as expected before pushing. Runtime errors will cause deployment to fail so make sure you have no bugs and you have all the following; Procfile, requirements.txt with all required packages and runtime.txt.

Commit all the changes we have made and then:

git push heroku master

If you are using main as the branch, change master to main

If you did everything correctly then the deployment should be done after a while with an output like this

Enumerating objects: 94, done.
Counting objects: 100% (94/94), done.
Delta compression using up to 8 threads.
Compressing objects: 100% (84/84), done.
Writing objects: 100% (94/94), 3.35 MiB | 630.00 KiB/s, done.
Total 94 (delta 24), reused 0 (delta 0)
remote: Compressing source files... done.
remote: Building source:
remote: 
remote: -----> Python app detected
remote: -----> Installing python-3.6.6
remote: -----> Installing pip
remote: -----> Installing requirements with pip
remote:        Collecting config==0.3.9 (from -r /tmp/build_19aebf8f25d534a39e73b13219af9927/requirements.txt (line 1))
remote:          Downloading https://files.pythonhosted.org/packages/0a/46/186ac016f3175211ec9bb4208579bc6dc9dd7dc882790d9f281533b83b0f/config-0.3.9.tar.gz
remote:        Collecting dj-database-url==0.5.0 (from -r /tmp/build_19aebf8f25d534a39e73b13219af9927/requirements.txt (line 2))
remote:          Downloading https://files.pythonhosted.org/packages/d4/a6/4b8578c1848690d0c307c7c0596af2077536c9ef2a04d42b00fabaa7e49d/dj_database_url-0.5.0-py2.py3-none-any.whl
remote:        Collecting Django==1.11 (from -r /tmp/build_19aebf8f25d534a39e73b13219af9927/requirements.txt (line 3))
remote:          Downloading https://files.pythonhosted.org/packages/47/a6/078ebcbd49b19e22fd560a2348cfc5cec9e5dcfe3c4fad8e64c9865135bb/Django-1.11-py2.py3-none-any.whl (6.9MB)
remote:        Collecting django-bootstrap3==10.0.1 (from -r /tmp/build_19aebf8f25d534a39e73b13219af9927/requirements.txt (line 4))
remote:          Downloading https://files.pythonhosted.org/packages/18/a8/f12d8491155c7f237084b883b8600faf722e3a46e54f17a25103b0fb9641/django-bootstrap3-10.0.1.tar.gz (40kB)
remote:        Collecting django-heroku==0.3.1 (from -r /tmp/build_19aebf8f25d534a39e73b13219af9927/requirements.txt (line 5))
remote:          Downloading https://files.pythonhosted.org/packages/59/af/5475a876c5addd5a3494db47d9f7be93cc14d3a7603542b194572791b6c6/django_heroku-0.3.1-py2.py3-none-any.whl
remote:        Collecting gunicorn==19.9.0 (from -r /tmp/build_19aebf8f25d534a39e73b13219af9927/requirements.txt (line 6))
remote:          Downloading https://files.pythonhosted.org/packages/8c/da/b8dd8deb741bff556db53902d4706774c8e1e67265f69528c14c003644e6/gunicorn-19.9.0-py2.py3-none-any.whl (112kB)
remote:        Collecting Pillow==5.2.0 (from -r /tmp/build_19aebf8f25d534a39e73b13219af9927/requirements.txt (line 7))
remote:          Downloading https://files.pythonhosted.org/packages/d1/24/f53ff6b61b3d728b90934bddb4f03f8ab584a7f49299bf3bde56e2952612/Pillow-5.2.0-cp36-cp36m-manylinux1_x86_64.whl (2.0MB)
remote:        Collecting psycopg2==2.7.5 (from -r /tmp/build_19aebf8f25d534a39e73b13219af9927/requirements.txt (line 8))
remote:          Downloading https://files.pythonhosted.org/packages/5e/d0/9e2b3ed43001ebed45caf56d5bb9d44ed3ebd68e12b87845bfa7bcd46250/psycopg2-2.7.5-cp36-cp36m-manylinux1_x86_64.whl (2.7MB)
remote:        Collecting python-decouple==3.1 (from -r /tmp/build_19aebf8f25d534a39e73b13219af9927/requirements.txt (line 9))
remote:          Downloading https://files.pythonhosted.org/packages/9b/99/ddfbb6362af4ee239a012716b1371aa6d316ff1b9db705bfb182fbc4780f/python-decouple-3.1.tar.gz
remote:        Collecting pytz==2018.5 (from -r /tmp/build_19aebf8f25d534a39e73b13219af9927/requirements.txt (line 10))
remote:          Downloading https://files.pythonhosted.org/packages/30/4e/27c34b62430286c6d59177a0842ed90dc789ce5d1ed740887653b898779a/pytz-2018.5-py2.py3-none-any.whl (510kB)
remote:        Collecting whitenoise==3.3.1 (from -r /tmp/build_19aebf8f25d534a39e73b13219af9927/requirements.txt (line 11))
remote:          Downloading https://files.pythonhosted.org/packages/0c/58/0f309a821b9161d0e3a73336a187d1541c2127aff7fdf3bf7293f9979d1d/whitenoise-3.3.1-py2.py3-none-any.whl
remote:        Installing collected packages: config, dj-database-url, pytz, Django, django-bootstrap3, whitenoise, psycopg2, django-heroku, gunicorn, Pillow, python-decouple
remote:          Running setup.py install for config: started
remote:            Running setup.py install for config: finished with status 'done'
remote:          Running setup.py install for django-bootstrap3: started
remote:            Running setup.py install for django-bootstrap3: finished with status 'done'
remote:          Running setup.py install for python-decouple: started
remote:            Running setup.py install for python-decouple: finished with status 'done'
remote:        Successfully installed Django-1.11 Pillow-5.2.0 config-0.3.9 dj-database-url-0.5.0 django-bootstrap3-10.0.1 django-heroku-0.3.1 gunicorn-19.9.0 psycopg2-2.7.5 python-decouple-3.1 pytz-2018.5 whitenoise-3.3.1
remote: 
remote: -----> Discovering process types
remote: 
remote: -----> Compressing...
remote:        Done: 56.3M
remote: -----> Launching...
remote:        Released v6
remote:        https://mtr1bune.herokuapp.com/ deployed to Heroku
remote: 
remote: Verifying deploy... done.
To https://git.heroku.com/mtr1bune.git
 * [new branch]      master -> master

Run Migrations

heroku run python manage.py migrate

If you wish to push your postgres database data to Heroku then run

heroku pg:reset
heroku pg:push <The name of the db in the local psql> DATABASE_URL --app <heroku-app>

You can the open the app in your browse.

Last comment

Don't beat yourself up when you find it challenging to memorize language or library syntax. They have documentation for a reason, so feel free to reference it. The syntax will stick to your memory on frequent use.💯✍️

Mastering Python for Web Development

It's pronounced W3SHY — Sun, 01 May 2022 08:54:41 +0000

Into

Everybody’s online today. It doesn’t matter if it’s about commerce, government, gaming, banking, social media, everybody who has a connection is on the internet.

Consequently, there’s a greater demand for engaging, user-friendly websites to interact with. That’s why the IT world turns to web development to get those well-designed websites created and launched.

Python is one of the most popular programming languages available. Today, we are exploring Python web development, what it is, the pros and cons of using Python for web development, and how to prepare yourself to use Python in a web development project.

But first, a quick word about the Python Language

Refresher

Python is a high-level, object-oriented programming language that has made tremendous strides in popularity thanks to its ease of use, even among non-programmers. It features a simple, easy-to-use syntax, and strong modular support.

What is Web Development

Web development is the catch-all term for conceptualizing, creating, deploying, and operating web applications and application programming interfaces (API) for the internet. It usually involves the front end, which entails everything that interacts with the user, and the back end, which requires business logic and database interaction.
It also includes full stack development, which means developing all parts of the application, from the front to the back.
So, if you’re trying to create a website or a web application, you’re engaging in web development. Since the demand for websites and apps is more significant than ever, it’s a much-needed skill and occupation.

Python Web Development

If you want to master Python web development, you should follow these steps. You don’t have to be a programmer to tackle this but there are specific skills and concepts that you should become familiar with before taking on development tasks.

Learn CSS and HTML. These two languages are the building blocks used to create websites. Learn them and use that knowledge to learn how to structure responsive static pages.
For extra credit, familiarize yourself with a CSS framework like Bootstrap or Materialize.
Learn Basic JavaScript. Next, learn vanilla JavaScript. “Vanilla” means using plain, ordinary JavaScript without additional libraries such as jQuery.
Familiarize yourself with concepts like control statements, data types, general conventions, variables, string manipulation, arithmetic and operators, and loops.
Learn About DOM and jQuery. Once you get the JavaScript fundamentals down, you should learn about the JavaScript library jQuery and manipulating the Document Object Model (DOM).
Learn Python. Yes, here is where you finally learn Python. Cover the basics and fundamentals, and you will be ready to tackle the application’s back end.
Learn Database and Django. Familiarize yourself with databases, the CRUD functions (create, read, update, and delete), and how to make queries. Django helps you set up the backend environment and develop business logic.

Ending Thoughts

Web development using Python has been very popular for years – and for all the right reasons. Not only is it a perfect language for beginners but it can also serve you as stepping stone for learning more complicated languages. Python web development is something every developer should give a try. Learning it is a piece of cake while the benefits of learning Python are amazing, especially when it comes to working on a short deadline and/or on a budget.

Python 101: The Ultimate Python Tutorial for Beginners

It's pronounced W3SHY — Sun, 24 Apr 2022 11:40:42 +0000

Is this the first time you are thinking about coding and becoming a programmer? Here I will help you with the simple python basics to get you started.

Introduction to Python

Python was created in the late 1980's by Guido Van Rossum. It is maintained and supported by the Python Software Foundation.
Python is a general-purpose programming language. It is used in various fields such as mathematics, agriculture, electronics, and mechanics.

It is a Strongly Typed language- meaning that every object in Python has a definite type associated with it
It is also Dynamically Typed- meaning that no type checking is done prior to running Python code.
Python is an Interpreted Language. This means that code compilation and execution is done at the same time.

Where can we use Python?

The Python language is used in many different fields.

Web Development - Python is used to create really dynamic websites using frameworks like Flask and Django.
Scientific Computing - It has several libraries dedicated to it for scientific computing like numpy, and earthpy for earth sciences.
Game Development - Python has a gaming library called pygame for creating games that use keyboard and mouse interactions.
Desktop Applications - Python comes with tkinter a graphical user interface library that allows us to create user interfaces for our applications.

Several companies use Python in their day-to-day running's. Here is a list of just a few:

Google (YouTube)
NASA
IBM
Mozilla
Quora
Instagram
Reddit
Disney

Installation

Go to the Python's Downloads Page and download the latest version.

NOTE: Always ensure that python has been correctly downloaded and is able to run on your PC. To check if it is properly installed on your machine.

Windows
On the Start menu or search bar find Python and click Enter then try running it or try using the following command line one the Terminal:
C:\Users\user>python --version

Mac OS/ Linux
To verify if python was successfully installed, open your Terminal and run the command line.
python3 --version

This is what you see,

C:\Users\user>python --version
Python 3.9.7

Python Basics

Strings - In Python, we can create strings with either single quotes (') or double quotes (") and Python treats them as the same thing.

>>> 'This is a string'
This is a string
>>> "This is also a string"
This is also a string

There are also some string methods that allow us to perform actions on the string.

>>> 'This is a string'.upper()
THIS IS A STRING
>>> 'this is a string'.capitalize()
This is a string

>>> 'this is a string'.strip()
This is a string

The upper() method is used to transform strings to uppercase.
The capitalize() method transforms the first letter of the string to a capital letter.
The strip() method removes any trailing spaces in a string.

Numbers - We can also do some mathematical computations in Python.

>>> 3 + 2 # addition
5
>>> 31 - 10 # subtraction
21
>>> 3 * 4 # multiplication
12
>>> 12 / 3 # division
4.0
>>> 12 % 5 # modulus
2
>>> 2 ** 4 # Exponential
16

Here, we see a new character #. This hash or pound sign is Python's way to create comments. Anything after the # is ignored by the Python interpreter.
Notice that when we use the / operator, Python doesn't return a whole number, but a number with a decimal point. It is referred to as a float division. Decimal point numbers in Python are called floats.

>>> 30 / 5
6.0
>>> 45 / 9
5.0
>>> 25 // 5
5

Here we see some more examples using the / to get floats. We also see another division operator in Python: //. This divides the numbers, then rounds down the result and returns a whole number, and is called the integer division.

Data Types

int: whole numbered integers
float: integers with decimal points.
None: represents a null or non-existent value.
bool: represent boolean statements and have only 2 possible values: True or False

Collections

As the name suggests, collections store multiple values.

str - This data type is used to represent string values
byte - This data type is used to represent byte strings.
list - This is a collection used to group related data in an ordered way. Learn More
dict - These allow us to create dictionaries which is data that is stored in key-value pairs. Learn more

Variables

Variables are named references to objects.
Here is an example of how we create a variable in Python in the Python shell:

>>> x = 4
>>> x
4

Python variables can store values from any data type. Python is dynamic in nature hence we do not have to specify what type of data we are storing.

>>> x = 12
>>> x
12
>>> x = "Hello"
>>> x
Hello
>>> pie = 3.1423
>>> pie
3.1423

`input()` function

The input() function is called inside our Python application and prompts the user to pass in an input, which is stored as a string

input_demo.py

print("What is your name?")
name = input()

print("How old are you?")
age = int(input())

print(name)
print(age)

We run the file:

$ python3 input_demo.py
"What is your name?"
James
"How old are you?"
19

James
19

Control Flow

Up to now our applications haven't been that interesting. Let us add some logic to our applications.

if statements
An if statement runs only when the condition passed to it evaluates to true

input_demo.py

height = 74 # The unit is inches
if height > 70 :
    print("You are really tall")

Run the file in the console:

$ python3.6 input_demo.py
You are really tall

Python uses indents. Indents are just four spaces we give to our application to define blocks of code. If we don't indent blocks of our code, we get an IndentationError and our program won't run.

Comparison Operators
Let us look at some of the comparison operators we will be using in Python

> Greater than
< Less than
== Equal to
!= not equal to
>= Greater than or equal to
<= Less than or Equal to
and checks if both conditions evaluate to true
or checks if at least one condition is true
not returns the opposite of the condition given

else
The else statement comes right at the end of the if statement. It is run only when the if statement evaluates to False. Let's add an else statement to our example program:

input_example.py

height = 54 # inches
if height > 70 :
    print("You are really tall")
else:
    print("You are really short")

Now when we run the file, we get a different message:

$ python3.6 input_demo.py
You are really short

elif
What if we have more than one condition to check for? We can use elif, which will allow us to check for multiple conditions. Looking at our example:

height = 68 # inches
if height > 70 :
    print("You are really tall")
elif height > 60:
    print("You are of average height")

else:
    print("You are really short")

Now let's run it:

$ python3.6 input_demo.py
You are of average height

Since the height is greater than 60, the elif statement will be executed first and Python never reaches the else statement.

Looping

A loop is a way to execute some piece of code over and over again. There are 2 kinds of loops in Python;

for loop
while loop

Learn more on Loops

Functions

We have already used functions to perform several tasks but let's learn how to create our own functions in python.

Functions are blocks of code that begin with the def keyword

def fun_a():
    print("I have been called")

fun_a()

"I have been called"

This example we have created a function with no arguments and in the function we have a print statement that outputs a string

Passing Arguments
In python you can also pass arguments to functions

def fun_a (a,b):
    print(a+b)

fun_a(1,4)
5

Learn more on Functions

Exceptions and Error Handling
There are some error that are caused by programmers themselves. These errors should not be handled but fixed.

IndentationError - when you fail to separate code blocks properly.
NameError - when you call an undefined variable function or method.
TypeError - when you try and perform operations on unrelated types.

DEV Community: It's pronounced W3SHY

Why ViTest is a Powerful Testing Framework for TypeScript Projects

Introduction

1. Minimal Setup and Configuration

2. Concise and Readable Syntax:

3. TypeScript Integration:

4. Performance and Test Execution Speed:

My Final Thoughts

Conclusion

REST APIs with Django Djoser

Introduction

Django Djoser

Lets Get started

Conclusion

Resources

Connect With Me

The difference on AbstractUser and AbstractBaseUser

Introduction

First, we explain…

AbstractUser

AbstractBaseUser

From what we have seen...

In Conclusion, which one should you use?

How to Deploy Django Applications on Heroku

Install Heroku CLI

Creating App

Preparing the Application

Assumptions

Procfile

runtime.txt

Configuring Whitenoise: Django Static Files settings

python-decouple and dj-database-url

.env

Deploying the app to Heroku

Pushing to Heroku

Run Migrations

Last comment

Mastering Python for Web Development

Into

Refresher

What is Web Development

Python Web Development

Ending Thoughts

Python 101: The Ultimate Python Tutorial for Beginners

Introduction to Python

Where can we use Python?

Installation

Python Basics

Data Types

Collections

Variables

input() function

Control Flow

Looping

Functions

`input()` function