DEV Community: Adzy

Does it ever happen to you?

Adzy — Mon, 02 Sep 2024 15:49:54 +0000

Well, I would like to keep this short, but sometimes nowdays, I feel very tired and sad.

I don't get any motivation to do anything.

It's been about 2 months since I have touched my computer and did any programming.

Is this mid life crisis (but I am just 19).

My health is also not very good, because of my renal agenesis my body couldn't produce enough heamoglobin so that I have a very bad case of anemia.

I don't know what should I do.

Infinite Scroll Pagination in Django with HTMX

Adzy — Sat, 14 Oct 2023 07:20:45 +0000

A few years ago I made a webapp in Django.
I also added the pagination in it. But something was missing.

Yes, it was Infinite Scroll Pagiantion

So in this todays blogpost, we are going to be making an Infinite Scroll Pagination in Django using HTMX

Also, the paginator will still work even if the users Javascript is disabled

Firstly let's create a django project and a django app

Install django

python -m pip install django

Creating a django app and project

django-admin startproject InfiniteScroll

cd ./InfiniteScroll

python manage.py startapp core

Adding our django app in the INSTALLED_APP in InfiniteScroll/setting.py

# Application definition

INSTALLED_APPS = [
    'django.contrib.admin',
    'django.contrib.auth',
    'django.contrib.contenttypes',
    'django.contrib.sessions',
    'django.contrib.messages',
    'django.contrib.staticfiles',

    # Our Apps
    'core.apps.CoreConfig' #<-- ADD THIS
]

To help with some things let's create a utility file named utils.py in our core app.

from django.core.paginator import Paginator


def is_htmx(request, boost_check=True):
    hx_boost = request.headers.get("Hx-Boosted")
    hx_request = request.headers.get("Hx-Request")
    if boost_check and hx_boost:
        return False

    elif boost_check and not hx_boost and hx_request:
        return True


def paginate(request, qs, limit=2):
    paginated_qs = Paginator(qs, limit)
    page_no = request.GET.get("page")
    return paginated_qs.get_page(page_no)

The is_htmx will check if the request is originating from htmx or not. It will also check if the request is boosted

The paginate function will help us to paginated the queryset. You can adjust the limit parameter if you want. For testing purposes I set the limit to 2

In the views.py add this

from django.shortcuts import render

from django.contrib.auth.models import User

from .utils import is_htmx, paginate

# Create your views here.


def index(request):
    users = paginate(request, User.objects.all())
    if is_htmx(request):
        return render(request, "islands/user_list.html", {"users": users})
    return render(request, "index.html", {"users": users})

Here we are returning the user list and if the request is a htmx request then we are returning the partials

Let's Create the templates

templates/islands/pagination.html

<div {% if page.has_next %} hx-get="?page={{ page.next_page_number }}" hx-trigger="revealed"
hx-swap="outerHTML" {% endif %}>
    {% if page.has_next or page.has_previous %}
    <nav class="pagination is-centered is-small mt-2" role="navigation" aria-label="pagination">
        <ul class="pagination-list">
            {% if page.has_previous %}
            <a class="pagination-link" aria-label="Goto page 1" href="?page=1">First Page</a>
            <a class="pagination-link" href="?page={{ page.previous_page_number }}">«
                Previous</a>
            {% endif %}
            <a class="pagination-link is-current" aria-label="Goto page {{ page.number }}">{{ page.number }}</a>
            {% if page.has_next %}
            <a class="pagination-link" href="?page={{ page.next_page_number }}">Next page
                »</a>
            <a class="pagination-link" aria-label="Goto page 4&amp;query="
                href="?page={{ page.paginator.num_pages }}">Last
                Page</a>
            {% endif %}
        </ul>
    </nav>
    {% endif %}
<script>
    htmx.on("htmx:load", function (evt) {
        document.querySelector(".pagination").style.display = "none";
    });
</script>
</div>

The .pagination element is have the following attributes

hx-get: The link to the next page
hx-trigger: The trigger event that will call the endpoint
hx-swap: The type of swap to occur. Here it's outerHTML

This code is pretty simple.
Firstly we are checking if there is a next page or not using django, then if there is a page then we are calling the ?page={{ page.next_page_number }}, for example, if the current page is 1 then the {{ page.next_page_number }} will return 2 and so on

Next we have the type of trigger event.
It means which events should occur to fire the request from the htmx. In this case its revealed means when the pagination element is revealed then htmx will fire the request. More Info

And finally we have our hx-swap, means when the htmx will get the response we want to replace all the html in .pagination with the response html
More Info

Here we are hiding the .pagination on every htmx request. If the js is disabled then the user will get the pagination buttons.

This is called Progressive Enhancement

templates/islands/user_list.html


{% for user in users %}
<div class="box">
    <p class="subtitle is-1">{{ user }}</p>

    {% if user.is_staff %}
        <span class="tag is-success">Staff</span>
    {% endif %}

</div>
    <br>
{% endfor %}
{% include 'islands/pagination.html' with page=users %}

This is just a simple django template file which will take the list of users and show them using a for-loop

We also have our pagination template which will be renderd after the user list.

templates/index.html

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Infinite Scroll Pagination</title>
    <script src="https://unpkg.com/htmx.org@1.9.6"></script>
    <link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/bulma@0.9.4/css/bulma.min.css">
    <link rel="stylesheet" type="text/css" href="https://unpkg.com/bulma-prefers-dark" />

</head>
<body>
    <div class="container">
        <section class="section">

            {% include 'islands/user_list.html' %}
        </section>
    </div>

</body>
</html>

Here we are using the bulma and bulma-prefers-dark to style our page

As you can see we can use our partial templates anywhere in our code so we can just include the islands/user_list.html in the index.html

Now finally hook it up in the urls.py

InfiniteScroll/urls.py

from django.contrib import admin
from django.urls import path

from core.views import index  #<-- ADD THIS

urlpatterns = [
    path('admin/', admin.site.urls),

    path('', index), #<-- ADD THIS
]

Import the index view from core.views and map it in the urlpatterns

Now lets create a superuser to login in the admin panel

python manage.py createsuperuser

Run the server and got to http://localhost:8000/admin/auth/user/ to add some more users and then go to the index page to check it

python manage.py runserver

User Add in admin panel

Index page, with javascript

Index page, without javascript

DEMO

Phew!

So thats how you can do it.

Bye.

Peace ✌
@foxy4096 out.

Explain me Docker like I'm 5 🐳

Adzy — Tue, 08 Aug 2023 04:22:47 +0000

I only know that it's logo is a whale.

Source:

Cover: dev.betterdoc.org
Post Image: icon8

Cheers ✌

WebSocket in Django

Adzy — Wed, 24 May 2023 06:43:46 +0000

What are WebSocket?

Well, they are computer communication protocol which is used to communicate bidirectionally.
It can be used by server to send data to the client.

In short, they are used for real-time communication.
Example: Chat applications, real-time data sync in games, SSE etc.

Thought WebSocket seems cool they could get too overpacked for simple apps like a weather app which polls data between few intervals.

How can you implement them in Django?

Well, that's easy we can use a python package called channels.
They are built by the same developers who have made Django.

Just open up a terminal and type the following to install the channels

python -m pip install -U channels["daphne"]

It will install channels and a special ASGI web server called daphne which is used to handle the ws:// protocol.

We will also be needing [django](https://pypi.org/project/Django/) of course, just enter the following command to install it

pip install django

We also might need to get redis and channel_redis

pip install redis channel_redis

And also don't forget the real redis itself from Redis

If you are on windows, you can use memurai

Now in this post, we will be making an Online User Presence Indicator. This app will tell the client the number of users connected to the server.

Also we will not be using the channel_layer to broadcast the message, as it will over complicate the things.

Create a django application

django-admin startproject django_websocket

Go to the django_websocket folder and type this command to create a new django app.

cd django_websocket
python manage.py startapp presence

In settings.py add the daphne server and our presence app.

Add daphne to the top.

# django_websocket/settings.py

INSTALLED_APPS = [
    'daphne' # ⬅ ASGI Webserver
    'presence', # ⬅ Our Custom App
    'django.contrib.admin',
    'django.contrib.auth',
    'django.contrib.contenttypes',
    'django.contrib.sessions',
    'django.contrib.messages',
    'django.contrib.staticfiles',
]

Add the following lines in the settings.py to allow the django to also handle ASGI and also handle the login and logout redirect.

# django_websocket/settings.py
# Daphne Conf
ASGI_APPLICATION = "django_websocket.asgi.application"

LOGIN_REDIRECT_URL = "index"
LOGOUT_REDIRECT_URL = "index"

Now let's add some code in asgi.py and replace the code with this:

import os

from django.core.asgi import get_asgi_application
from channels.routing import ProtocolTypeRouter # <- Add this
from channels.auth import AuthMiddlewareStack # <- Add this
from presence.consumers import PresenceConsumer # <- Add this

os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'django_websockets.settings')

application = ProtocolTypeRouter(
    {
        "http": get_asgi_application(),
        "websocket": AuthMiddlewareStack(
            PresenceConsumer.as_asgi()
        ),
    }
)

Let's break it down:

From line 1 to 6 we are importing all the required modules
- os: For setting some required environment variables
- get_asgi_application: Just handles the http side of our application.
- ProtocolTypeRouter: Allow us to handle different type of protocol interfaces, like for http we will just do the http things but for WebSocket protocol connections we will let our application handle with the websockets part.
- AuthMiddlewareStack: Supports standard Django authentication, where the user details are stored in the session. It allows read-only access to a user object in the scope. In short it allows us to get the current request.user
- PresenceConsumer: It our custom made ASGI consumer which will handle the websockets. We will be making this next
- Line 8 is where we are adding the file is adding the project settings.py in an env named DJANGO_SETTINGS_MODULE. We don't have to worry about it.
- From line 10 to 17 is where we are declaring the application It is the same "django_websocket.asgi.application.
The application is equal to the ProtocolTypeRouter which takes a dictionary of protocols such as http and websocket
The WebSocket is taking a function called AuthMiddlewareStack which takes our Consumers

Now we get to the interesting part which is making the WebSocket consumers itself.

firstly, create a file name consumers.py in presence folder, and write this code in it.

import json

from channels.generic.websocket import WebsocketConsumer


class PresenceConsumer(WebsocketConsumer):

    connections = []

    def connect(self):
        self.accept()
        self.user = self.scope["user"]
        self.connections.append(self)
        self.update_indicator(msg="Connected")

    def disconnect(self, code):
        self.update_indicator(msg="Disconnected")
        self.connections.remove(self)
        return super().disconnect(code)

    def update_indicator(self, msg):
        for connection in self.connections:
            connection.send(
                text_data=json.dumps(
                    {
                        "msg": f"{self.user} {msg}",
                        "online": f"{len(self.connections)}",
                        "users": [f"{user.scope['user']}" for user in self.connections],                        
                    }
                )
            )

Now this code may look intimidating, but actually it's pretty simple once you understand the basic concept of Consumers.

Let's break it down.

From line 1 to 3, we are importing some important modules such as json and WebsocketConsumer.
From line 6 we are creating a class named PresenceConsumer which is extended from WebsocketConsumer
- The WebsocketConsumer gives us some of the methods for the WebSocket like
  - connect method is called when client connects to the WebSocket. If we are overriding this method, then we have to add self.accept().
  - disconnect method is called when client disconnects to the WebSocket.
  - receive method is called when the client sends request to the to the WebSocket
The method named update_indicator is a custom method which we have created.
The connections is an empty list which will store the connected users.

In the connect method, we are overriding the methods so that when a new user connects to the WebSocket, we are getting the user from the session with this code self.user = self.scope["user"], as we have wrapped our PrescenceConsumer in AuthMiddlewareStack, we can get the current user from the session and save it in the self.user. After we got the user, we are going to append the current user connection to the connection and then calling the self.update_indicator and passing the msg as connected.

Now if we look in the update_indicator we can see that we are looping through the connection list and sending the all the client a json data.

Example:
If a user named Sid connects to the WebSocket with 3 users connected all the clients connected to the WebSocket including Sid will get the following json

{
    "msg": "Sid Connected",
    "online": 4,
    "users" [
                "user1",
                "user2",
                "user3",
                "Sid"
            ]
}

Now we will handle some of our views for displaying the index page and login page. Just add this 4 lines of code and you are done

from django.shortcuts import render

def index(request):
    return render(request, "index.html")

Yup that's it.

Now we will handle the routing of the WebSocket.

This is just like url mapping your views in a typical django app.

Now mostly in a very large scale applications we should just seperate the views routing and ws routing, but here to save time we are just going to write it in the urls.py

Firstly create a urls.py file in the presence app and add the following code.

from django.urls import path

from . import consumers
from . import views
from django.contrib.auth.views import LoginView, LogoutView


urlpatterns = [
    path('', views.index, name="index"),
    path('login/', LoginView.as_view(template_name='login.html'), name='login'),
    path('logout/', LogoutView.as_view(), name='logout'),
    path("ws/presence", consumers.PresenceConsumer.as_asgi()),
]

Here we are creating an URL mapping for our views and WebSocket.
As you can see, we are also using the django authentication views to get login and logout functionality in our app.

To add the WS Consumer we just need to map it in the urlpatterns just like any other class based views, just instead of .as_view(), here we write .as_asgi().

Phew! That was the backend part, now we need to setup our frontend part.

Now Let's Get to the frontend part

Create a template directory in the presence app and create two files named index.html and login.html

In the index.html write the following code.

<!DOCTYPE html>
<html>

<head>
  <meta charset="utf-8" />
  <title>Online Presence Indicator</title>
  <link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/bulma@0.9.4/css/bulma.min.css">
</head>

<body>
  <div class="container">
    <section class="section">
      <div class="columns">
        <div class="column">

          {% if user.is_authenticated %}
          Hello <strong>{{ user }}</strong>
          <br>
          <a href="{% url 'logout' %}">Logout</a>
          {% else %}
          <a href="{% url 'login' %}">Login</a>
          {% endif %}
          <h1 class="title">Online Presence Indicator</h1>
          <div id="presence"><span class="tag is-success" id="pre_cnt">0</span> users online</div>
          <ul id="messages"></ul>
        </div>
        <div class="column">
          <div class="box">
            <h1 class="title">Online Users</h1>
            <div id="online-users"></div>
          </div>
        </div>
      </div>
    </section>
  </div>

  <script>
    const ws = new WebSocket('ws://localhost:8000/ws/presence/');
    const presenceEl = document.getElementById('pre_cnt');
    const messagesEl = document.getElementById('messages');
    const onlineUsers = document.querySelector("#online-users");

    ws.onmessage = (event) => {
      onlineUsers.innerHTML = "";
      let data = JSON.parse(event.data)
      presenceEl.innerHTML = data.online;
      const li1 = document.createElement('li');
      li1.innerHTML = data.msg;
      messagesEl.appendChild(li1);
      data.users.forEach(user => {
        const li2 = document.createElement("li");
        li2.classList.add("on-us")
        li2.innerHTML = user;
        onlineUsers.appendChild(li2);
      });

    };
  </script>
</body>

</html>

Here we are using Bulma to style our page, you can use your own stylesheet if you want.

The main thing we have to look here is the javascript.

Firstly we are creating a WebSocket object and passing the WebSocket url.
Next we are storing the html elements by using getElementById.
Then we are WebSocket.onmessage event handle to real-time messages from the server. The event contains a data attribute, to which we will use JSON.parse to convert the coming JSON to object
When the WebSocket receives the message from the serve we will show that the user is connected in the #messages div and append the user in #online-users div.

Now let's just quickly create our login page.
Open login.html and write this html.

<!DOCTYPE html>
<html>

<head>
  <meta charset="utf-8" />
  <title>Online Presence Indicator</title>
  <link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/bulma@0.9.4/css/bulma.min.css">
</head>

<body>
  <div class="container">
    <section class="section">
        <h1 class="title">Login</h1>
      <form action="." method="post">
        {{form.as_p}}
        {% csrf_token %}
        <br>
        <button class="button">Login</button>
      </form>
    </section>
  </div>
</body>

</html>

Just that's it and now our application is complete.

Let's setup the database by running the migrations

python manage.py migrate

Let's now test it by running the server

python manage.py runserver

You should see the following stream.

Watching for file changes with StatReloader
Performing system checks...

System check identified no issues (0 silenced).
May 23, 2023 - 22:54:21
Django version 4.2.1, using settings 'myproject.settings'
Starting ASGI/Daphne version 4.0.0 development server at http://127.0.0.1:8000/
Quit the server with CTRL-BREAK.

We can see that Django is using ASGI/Daphne server to run this Website.

Now open up http://localhost:8000 and you should see the following page.

Index page with unauthenticated user

You will see that message box will have written AnonymousUser Connected

Let's create an account and test it.

python manage.py createsuperuser

Now that we have created the superuser, let's login with this account and see.

Login Page

Index page with authenticated user

Now open up a private page and open the both page in split view

Demo Video

Here is the GitHub link for the Source Code of this app: https://github.com/foxy4096/django_websocket_demo

So that's for it guys.

Cheers ✌

Implementing search in Django fbv

Adzy — Fri, 10 Feb 2023 10:30:20 +0000

So after about 2 years after I am writing this blog post.

What can I do?
I am very lazy...

After procrastinating for 2 years I've decided to finally write a blog post

I assume that you have some basic knowledge of Django requests and responses, like GET and POST request and URL mapping etc.

So, let's get to the point.

For example we have a model called Book

# models.py

from django.db import models

class Book(models.Model):
    """
    A Simple Book Model
    """
    ISBN_HELP_URL = "https://www.isbn- 
    international.org/content/what-isbn"

    name = models.CharField(max_length=255)
    author = models.CharField(max_length=255)
    summary = models.TextField(blank=True, null=True)
    isbn = models.CharField(help_text=f"<a href='{ISBN_HELP_URL}' 
    target='_blank'>More Info</a>", max_length=10)
    genre = models.CharField(max_length=255, help_text="Enter a 
    book genre (e.g. Science Fiction, French Poetry etc.)")

    def __str__(self):
        return self.name

So we want to make a page to search for a Book based on the following fields:

name
author
summary
isbn
genre

We can simply use the Q operator.
It is built in to Django.
It is used to Join the querysets.

Here is a simple example:

# views.py

from django.db.models import Q
from django.shortcuts import render, redirect
from .models import Book

def frontpage(request):
"""
The default frontpage

Return all the books in the database.
"""
books = Book.objects.all()
   return render(request, "frontpage.html", {"books": books})

def search(request):
    """
    Searches the books based on the query.
    """
    query = request.GET.get("query", None)
    if query:
        books = Book.objects.filter(
                Q(name__icontains=query) |
                Q(author__icontains=query) |
                Q(summary__icontains=query) |
                Q(isbn__icontains=query) |
                Q(genre__icontains=query)
        )
        return render(request, "search.html", {"books": books})

    return redirect(request, "frontpage")

Now that looks so complicated, but it isn't
If you understand what this code is doing you can easily implement in your projects

So let's break this down into pieces.

The function frontpage, well shows the frontpage with all the Books in the database, easy.
The search function searches the books based on the query entered by the user.
The query can match the name, author, summary, ISBN, or genre of the book.
If a query is entered, the function filters the books and returns the filtered books to be displayed in the "search.html" template.
If no query is entered, the function redirects the user to the "frontpage".

We are firstly importing the Q operator from django.db.models.
Then we are filtering the Books based on the fields

This is the main code

books = Book.objects.filter(
                Q(name__icontains=query) |
                Q(author__icontains=query) |
                Q(summary__icontains=query) |
                Q(isbn__icontains=query) |
                Q(genre__icontains=query)
        )

The | indicate that we are joining the queryset so even if the query isn't matched with the name but matched with the author it will fetch that book from the database

This double underscores and icontains represent that we also want to make the query case insensitive.

For example if we want to search for a Book named The Brief History of Time by Stephen Hawking,
We don't have to type the exact name of the book.
The Query could include the following:

the brief history of time
THE BRIEF HISTORY OF TIME
History of Time
brief history

The possibilities could get endless.

So now let's map the views to the urls

Open the urls.py

# urls.py

from django.contrib import admin
from django.urls import path
from myapp import views

urlpatterns = [
    path('', views.frontpage, name="frontpage"),
    path('/search/', views.search, name="search"),
    path('admin/', admin.site.urls),
]

Now let's move to the frontend

Create a folder in myapp (Your app folder) named as templates.
In it create two files named:

frontpage.html
search.html

If you wish you can use a base.html and template inheritance, but here I will be doing the simple html with no css, so it will look ugly.

<!-- frontpage.html -->
<html>
  <head>
    <title>Jamshedpur Library</title
  </head>
  <body>
    <h2>Jamshedpur Library</h2>
    <p>Frontpage</p>
    <form action="{% url 'search' %}" method="GET">
    <input type="search" placeholder="search" name="query">
    <button type="submit">Search 🔍</button>
    </form>
    <ul>
      {% for book in books %}
        <li>{{ book.name }} by {{ book.author }}</li>
      {% endfor %}
    </ul>
  </body>
</html>

Yup it's a form which will send get request to search view, remember we have added a name attribute in the url patterns

Now let's see the search.html

<!-- search.html -->
<html>
  <head>
    <title>Jamshedpur Library</title
  </head>
  <body>
    <h2>Jamshedpur Library</h2>
    <form action="{% url 'search' %}" method="GET">
    <input type="search" placeholder="search" name="query">
    <button type="submit">Search 🔍</button>
    </form>
    <p>You have searched for: {{ request.GET.query }}</p>
    <p>Results: {{ books.count }}</p>
    <ul>
      {% for book in books %}
        <li>{{ book.name }} by {{ book.author }}</li>
      {% endfor %}
    </ul>
  </body>
</html>

So here we are displaying the search results with the no. of results just as in any search engine.

BTW I have not implemented the pagination, so the data isn't spliced into smaller chunks

Well that's how you can implement a simple search in your Django project.

Also, the letter Capital G looks like an arrow going in a circle.

Thanks for reading my post.

@foxy4096 out.
Cheers ✌

My Experience with GitHub Copilot

Adzy — Fri, 05 Nov 2021 14:07:03 +0000

Yup I got the access to the technical preview of this AI model who can destroy us or Not!

Well the answer is difficult to say but first let's understand what this thing is.

Well to put forward, this thing is simply like a autocomplete extension for Code [Visual Studio Code], Jetbrain IDEs and Neo VIM.
But not any kind of autocomplete tool, it is much more.

It can write the whole line or an entire function, just by reading your comment.

Well beginners should not use this tool as if they use this tool they will not learn anything about programing.

While using this, you should be careful that you don't get habit of using this,
Why?
Cause GitHub copilot uses internet and me living in an area where Internet is not available

Well I found it useful in writing in templates for html cause I really don't know how to properly use the power of html, css and JavaScript.

But I am turning it off because I feared that if I use it more then I might forgot how to code

Peace ✌️

Explain me async like I am a Kid

Adzy — Thu, 04 Nov 2021 13:07:59 +0000

Help me!

Peace ✌

Explain Me Cookies Like I Am 9

Adzy — Mon, 01 Nov 2021 09:47:06 +0000

Use your knowledge,

I am kinda busy these days.

Peace ✌

Remove duplicates from a list in Python

Adzy — Fri, 15 Oct 2021 04:18:21 +0000

I am going straight to the point

my_list = [1, 2, 3, 4, 4, 5, 2]

How do we remove duplicate no. or elements from the list.

Simple, we have 3 easy method.

1 Using set

my_list = [1, 2, 3, 4, 4, 5, 2]
updated_list = list(set(my_list))
print(updated_list)

#The output will be: [1, 2, 3, 4, 5]

As we know that set doesn't support duplicate, we can simply use this method to remove duplicates. Here I have type casted the list into a set and then again type casted in to list.

2 Using dict

my_list = [1, 2, 3 , 4, 4, 5, 2]
updated_list = list(dict.fromkeys(my_list))
print(mylist)

#The output will be: [1, 2, 3, 4, 5]

Well dict also doesn't support duplicates so when we convert the list to dict, so we are creating dict from the list and then converting it back to list.

3 I don't know what to call this method

my_list = [1, 2, 3 , 4, 4, 5, 2]
updated_list = []
for item in my_list:
    if item not in list:
        updated_list.append(item)
my_list = updated_list
print(my_list)

#The output will be: [1, 2, 3, 4, 5]

So that was 3 ways to remove duplicates from a list.
I you got some more methods write down in the comment box below, I would love to see them, until then bey bye and

Peace ✌

Top 4 Places To Learn Python

Adzy — Wed, 13 Oct 2021 06:08:55 +0000

In the last post I have shown you how to get started with python and print Hello World.

But what now ?

Well we need to know the basic.

So I have found top 4 sources to learn python.

1. W3School

W3Schools is a freemium educational website for learning coding online. Developed in 1998, its name is derived from the World Wide Web. It is run by Refsnes Data in Norway.
I also started learning about programming from this site

2. Python Docs

Yes really, the documentation contains everything about python if it is not stated anywhere in other places.

3. YouTube

YouTube contains more than 1000 tutorials about the Python.

4. RealPython

It's a nice website that will help you learn many things about Python. You really should see 😉

So that was top 4 places to learn python.
Let me know if you also know some websites/sources, I would love to see than

Till then Bye 👋
and
Peace ✌

How to print "Hello, World!"💻

Adzy — Tue, 12 Oct 2021 15:02:17 +0000

Printing "Hello, World!" is a kind of ritual that start the journey every programmer.

According to Wikipedia:
A "Hello, World!" program generally is a computer program that outputs or displays the message "Hello, World!". Such a program is very simple in most programming languages, and is often used to illustrate the basic syntax of a programming language. It is often the first program written by people learning to code.

In this post I will show you how to print "Hello, World!" in Python

This is first post and I am scared

Step 1: Download and Install Python

[skip this step if you have already installed it]

Just head to https://python.org/download/ and download the install the program supported by your os, i.e. .msi for windows and .dmg for mac

In the windows you have to tick the check box saying Add Python3.xx to path

For Linux you have to open an application named terminal and type the following command, make sure you are connected to internet and have sudo privilege.

Command to install python on Linux

sudo apt-get install python3.8

Step 2: Writing the program

Open a suitable text editor of your choice and type the following code and save it in .py extension

print("Hello, World!")

Here we are printing the "Hello, World!" with print function.
It is a built-in function in python which helps to print thing in the console window

If you wish you can skip this section

The print function have the following arguments

print(value, ..., sep=' ', end='\n', file=sys.stdout, flush=False)

Prints the values to a stream, or to sys.stdout by default.
Optional keyword arguments:
file: a file-like object (stream); defaults to the current sys.stdout.
sep: string inserted between values, default a space.
end: string appended after the last value, default a newline.
flush: whether to forcibly flush the stream.

Step 3: Running the program

In windows, open the folder in where is your program is located and press shift + right click to open the context menu and select the Open with powershell option

In Linux/Unix, open the folder in where is your program is located and press right click to open the context menu and select the Open in Terminal option

Now in the terminal type the following command

For Windows

python app.py

For Linux/Mac

python3 app.py

The following thing will be print

Hello, World!

So that was a simple tutorial on how to print "Hello, World!" in Python.
Well then see you all next time.

Peace ✌