DEV Community: Janet Awino

My Journey to Becoming a Frontend Developer

Janet Awino — Fri, 31 Jan 2025 10:49:22 +0000

Frontend Development is an important part of software development because it creates interfaces that shape user experiences. I want to become a front-end developer to create visually appealing and user-friendly interfaces. Frontend development fascinates me because of the ability to solve problems creatively using technologies such as HTML, CSS, and JavaScript. Being a front-end developer will enable me to create amazing user interfaces that allow seamless navigation for users.

I believe HNG will help me sharpen my skills and gain real-world experience because the program provides an intense and immersive experience that accelerates learning. The internship provides a team-based setting which will enhance my collaboration and problem-solving abilities. For companies looking to build interactive and scalable front-end applications, they can Hire React.js Developers to speed up development and improve user experience. The program also has mentors who will guide us in writing clean and efficient code. The program is also well structured with hands-on projects therefore preparing us for real-world experience.

I have been looking forward to starting this internship because I believe it will help me achieve my goal of becoming a software developer. My goals for the internship are to improve my technical skills as a developer and build a strong portfolio. I aim to understand how to create modern UI components and improve accessibility. For businesses seeking professional front-end expertise, they can Hire UI Developers to create visually appealing and user-friendly web applications. I plan to achieve these goals by completing all the tasks at the right time and collaborating with learners from my track, and also seeking feedback from my mentors. The HNG Internship is the perfect opportunity to sharpen my skills, gain hands-on experience, and take a significant step toward becoming a professional front-end developer.

How to Use Eloquent ORM for Database Management in Laravel

Janet Awino — Wed, 27 Nov 2024 10:31:13 +0000

Laravel’s Eloquent ORM (Object-Relational Mapping) is one of the most popular features of the framework. It provides a clean, intuitive way to interact with your database, allowing you to work with tables as simple PHP objects. With Eloquent, you can handle complex database operations without writing long and repetitive SQL queries.
This article will walk you through the essentials of using Eloquent ORM for database management, covering everything from creating models to handling relationships and best practices. By the end, you’ll be equipped to use Eloquent effectively in your Laravel projects.

1. Setting Up Eloquent

Before diving into Eloquent, make sure you have a Laravel project set up. If you don’t already have one, you can create it by running the following command:

composer create-project laravel/laravel example-app

Configuring Your Database
Next, configure your database connection in the .env file located in the root directory of your Laravel project:

DB_CONNECTION=mysql  
DB_HOST=127.0.0.1  
DB_PORT=3306  
DB_DATABASE=your_database_name  
DB_USERNAME=your_username  
DB_PASSWORD=your_password

Run the following command to create the default database tables, such as the users table:

php artisan migrate

Your project is now ready to use Eloquent ORM.

2. Creating a Model

What is a Model?
A model in Eloquent represents a single database table. Each model corresponds to a table, and each instance of the model represents a row in that table. Models handle most of the data manipulation tasks in Laravel.
Creating a Model
To create a new model, use the Artisan command:

php artisan make:model Post -m

The -m flag creates a migration file for your model. This migration file defines the structure of the corresponding database table. Open the migration file in the database/migrations directory and define the columns:

Schema::create('posts', function (Blueprint $table) {  
    $table->id();  
    $table->string('title');  
    $table->text('body');  
    $table->timestamps();  
});

Run the migration to create the posts table:

php artisan migrate

3. Retrieving Data with Eloquent

Retrieving data is one of the most common tasks in database management. With Eloquent, this is incredibly simple.
Retrieve All Records
To fetch all records from a table, use the all() method:

$posts = Post::all();  
foreach ($posts as $post) {  
    echo $post->title;  
}

Retrieve a Single Record
You can fetch a single record using the find() method with a primary key:

$post = Post::find(1); 
echo $post->title;

Alternatively, use the first() method to retrieve the first matching record:

$post = Post::where('title', 'First Post')->first();

Use Filters and Conditions
Eloquent allows you to filter results with the where() method:

$posts = Post::where('title', 'like', '%Laravel%')->get();

4. Inserting Data with Eloquent

Eloquent simplifies the process of adding new records to your database.
Mass Assignment with Create Method
To use mass assignment, define the fillable property in your model to specify the fields that can be mass-assigned:

class Post extends Model  
{  
    protected $fillable = ['title', 'body'];  
}

Now you can create a new record like this:

Post::create([  
    'title' => 'New Post',  
    'body' => 'This is the body of the new post.',  
]);

Using the Save Method
Another way to add data is by creating a model instance and saving it:

$post = new Post();  
$post->title = 'Another Post';  
$post->body = 'This is another post body.';  
$post->save();

5. Updating Data with Eloquent

Find and Update
To update a record, fetch it first, then modify and save it:

$post = Post::find(1);  
$post->title = 'Updated Title';  
$post->save();

Direct Update Method
If you don’t need to fetch the record first, use the update() method:

Post::where('id', 1)->update(['title' => 'Another Updated Title']);

6. Deleting Data with Eloquent

Deleting a Record
To delete a specific record, find it first, then call the delete() method:

$post = Post::find(1);  
$post->delete();

Bulk Deletion
To delete multiple records based on a condition, use the where() method followed by delete():

Post::where('title', 'Old Post')->delete();

7. Eloquent Relationships

Eloquent supports relationships, making it easy to manage associations between tables.
One-to-One
A one-to-one relationship links one record in a table to one record in another.

// User model  
public function profile()  
{  
    return $this->hasOne(Profile::class);  
}

Fetch the profile of a user:

$user = User::find(1);  
$profile = $user->profile;

One-to-Many
A one-to-many relationship links one record in a table to multiple records in another.

// User model  
public function posts()  
{  
    return $this->hasMany(Post::class);  
}

Fetch all posts for a user:

$user = User::find(1);  
$posts = $user->posts;

Many-to-Many
A many-to-many relationship links records in one table to many records in another.

// Post model  
public function tags()  
{  
    return $this->belongsToMany(Tag::class);  
}

Attach tags to a post:

$post = Post::find(1);  
$post->tags()->attach([1, 2]);

8. Query Scopes

Query scopes allow you to reuse query logic.
Defining a Query Scope
Add a scope method to your model:

public function scopePopular($query)  
{  
    return $query->where('views', '>', 100);  
}  
Using a Scope
$popularPosts = Post::popular()->get();

9. Eloquent Events

Eloquent events let you perform actions during a model’s lifecycle.
Using Events
For example, automatically generate a slug when creating a post:
protected static function booted()

{  
    static::creating(function ($post) {  
        $post->slug = Str::slug($post->title);  
    });  
}

10. Best Practices for Eloquent ORM

Use Fillable Fields: Always define the fillable property to avoid mass assignment vulnerabilities.
Eager Load Relationships: Use with()to load related models in fewer queries.
Optimize Queries: Use scopes, caching, and indexingfor better performance.
Validate Inputs: Always validatedata before saving it to the database.

Conclusion

Eloquent ORM is a powerful and flexible tool for managing databases in Laravel. It simplifies common tasks like querying, inserting, updating, and deleting records while supporting advanced features like relationships and events. By mastering Eloquent, you can make your Laravel development faster and more efficient.
Try these examples in your next project to see how Eloquent can transform the way you handle database management.

MedusaJS: Building Server-side Applications

Janet Awino — Mon, 13 Mar 2023 04:06:07 +0000

MedusaJS is a popular backend JavaScript framework that allows developers to build scalable web applications. It is built on top of Node.js and uses the Express.js web framework to handle requests and responses. Its key features include easy integration with other libraries, a built-in ORM, and support for MVC architecture.

With MedusaJS, developers can focus on writing business logic and implementing features rather than dealing with the boilerplate code required to set up a server-side application. The framework uses ExpressJS under the hood, making it easy to get started with and familiar for developers who have worked with Express before.

Here's a sample code that demonstrates how to build a server-side application using MedusaJS:

const Medusa = require('medusa-js');
const bodyParser = require('body-parser');
const cors = require('cors');
const morgan = require('morgan');
const { User } = require('./models');

const app = new Medusa();

// Middleware
app.use(bodyParser.json());
app.use(cors());
app.use(morgan('dev'));

// Routes
// GET all users
app.get('/users', async (req, res) => {
  const users = await User.findAll();
  res.json(users);
});

// GET user by ID
app.get('/users/:id', async (req, res) => {
  const user = await User.findByPk(req.params.id);
  if (user) {
    res.json(user);
  } else {
    res.status(404).json({ error: 'User not found' });
  }
});

// POST new user
app.post('/users', async (req, res) => {
  const user = await User.create(req.body);
  res.json(user);
});

// PUT update user
app.put('/users/:id', async (req, res) => {
  const user = await User.findByPk(req.params.id);
  if (user) {
    await user.update(req.body);
    res.json(user);
  } else {
    res.status(404).json({ error: 'User not found' });
  }
});

// DELETE user
app.delete('/users/:id', async (req, res) => {
  const user = await User.findByPk(req.params.id);
  if (user) {
    await user.destroy();
    res.sendStatus(204);
  } else {
    res.status(404).json({ error: 'User not found' });
  }
});

// Error handling middleware
app.use((err, req, res, next) => {
  console.error(err.stack);
  res.status(500).json({ error: 'Internal server error' });
});

// Start the server
const PORT = process.env.PORT || 3000;
app.listen(PORT, () => {
  console.log(`Server started on port ${PORT}`);
});

In this code, we start by importing the necessary dependencies and our User model. We then create a new instance of the Medusa class and define our middleware stack, which includes the body-parser, cors, and morgan middleware.

Next, we define our routes for CRUD operations on users. We use the async/await syntax to await the results of queries to the database through SequelizeJS, as these operations are asynchronous.

Finally, we define an error-handling middleware function that logs errors to the console and sends a 500 Internal Server Error response to the client when an error occurs. We then start the server listening on the appropriate port, which is either specified through the PORT environment variable or defaults to port 3000.

In conclusion, this code shows how to build a fully-functional server-side application using MedusaJS, with support for creating, reading, updating, and deleting user records from a PostgreSQL database. If you are looking for a lightweight and flexible way to build server-side applications with JavaScript, MedusaJS is definitely worth checking out.

Web Scraping: Python and Beautiful Soup

Janet Awino — Thu, 05 Jan 2023 07:21:06 +0000

Introduction

Web scraping is a technique used to extract data from websites. It involves making HTTP requests to a web's server, downloading the HTML content of the webpage, and parsing that content to extract the data you are interested in. It is when someone takes a specific part of a website and copies all the data from that section into their program. Web scraping allows you to collect the raw data you need from websites with no APIs or sites that don't allow access via API.

There are a ton of great tools out there for web scraping. Different tools work with different languages and allow for different types of scraping. This article will look at web scraping using Python and Beautiful Soup. Beautiful Soup is a Python library for extracting data from HTML and XML files. It allows you to parse a document into a tree of text nodes, call methods on the nodes, and access the contents of HTML elements.

This article will demonstrate web scraping using the Beautiful Soup library from the Big Square site. We will scrape the website's product names and prices, and save the data to a CSV file.

Prerequisites

The following are the requirements for this tutorial:

Familiarity with Python programming language.
Knowledge of HTML and CSS.
Familiarity with the command line
Understanding of the request and response cycle.

What is the Process of Web Scraping?

The process of web scraping using Python and Beautiful Soup typically involves the following steps:

1.Installing the required libraries i.e. beautiful soup and request.

We will begin by creating a virtual environment before installing the packages. To do that, create a project folder, navigate to the project folder then run the following command in the terminal:

python -m venv scrapy

Here, scrapy is the name of the virtual environment that we have created but you can name it anything you want.
To activate the virtual environment type the following command in the terminal:

scrapy\Scripts\activate.bat

You can learn more about virtual environments here.

Now that we have created a virtual environment, we are ready to install the libraries. The libraries are installed using the pip command as shown below. Install the requests library by running the following command:

python -m pip install requests

2. Sending request to the URL of the website to scrape.

We will make an HTTP GET request to the website and print the HTML content of the webpage. To do that, create a file named main.py and paste in the code below:

import requests

content = requests.get("https://bigsquare.co.ke/").text

print(content)

This code imports the requests library, which allows you to send HTTP requests using Python. The code then uses the get function from the requests library to send a GET request to the specified URL Big Square. The response is then assigned to a variable called "content". The response from the GET request is in bytes format and the .text is used to convert it to a string format. Finally, the code prints the content of the response, which is the HTML source code of the website.

3. Parsing the HTML content using beautiful soup library

We will install beautiful soup using the terminal as we did with requests by typing the following in the terminal:

python -m pip install beautiful soup

We can replace the existing code with the code below to create a beautiful soup object:

from bs4 import BeautifulSoup

import requests

content = requests.get('https://bigsquare.co.ke/').text

info = BeautifulSoup(content, "html.parser")

print(info.prettify())

In this code snippet the HTML content is passed as an argument to the BeautifulSoup constructor, along with the "html.parser" argument, which tells BeautifulSoup to use the built-in HTML parser to parse the content.
The resulting BeautifulSoup object, stored in the 'info' variable, is then printed using the 'prettify()' method, which formats the HTML content in a readable way.

4. Navigating the parse tree

We can use various methods to extract the data we want from the HTML or XML document. For example, we can use the find or find_all methods to search for specific HTML tags and extract their contents.

product_divs = soup.find_all("div", class_="product")

This will return a list of BeautifulSoup objects representing all the div elements on the page with the class "product". We can then iterate over this list and extract the data we want from each element:

for div in product_divs:
    name = div.find("h3").text
    price = div.find("span", class_="price").text
    print(name, price)

This script goes through each element in the list of "product_divs" using a for loop. Within the for loop, the code uses the find() method provided by BeautifulSoup to locate specific elements within the current "div" element.

The first line of the for loop uses the find() method to locate an h3 element within the current "div" element, and then extracts the text content of that element. This text content here is the the name of a product.

The second line uses the find() method again, this time to locate a span element with the class "price" within the current "div" element, and then extracts the text content of that element. This text content is the price of the product.

5. Saving the data

Once we have extracted the data we want, we can save it to a CSV or Excel file using the csv or openpyxl libraries respectively. Here we will save it to a CSV file.

import csv

with open("products.csv", "w", newline="") as csv_file:
    writer = csv.writer(csv_file)
    writer.writerow(["Name", "Price"])
    for div in product_divs:
        name = div.find("h3").text
        price = div.find("span", class_="price").text
        writer.writerow([name, price])

In this code snippet we use the "csv" library in Python to write the data to a file. The first line is opening a file named "products.csv" in write mode ("w") and creating a csv_file object. The "newline" parameter is specified to ensure that new rows are properly written to the file.

Then, a CSV writer object "writer" is created using the csv_file object, and it writes the headers "Name" and "Price" to the file.

Then, the script loops through all the div elements in the "product_divs" class and extracts the text of the h3 element (product name) and the text of the span element with a class of "price" (product price) as before, but this time instead of printing the data, it is writing the rows of data to the CSV file.

Conclusion

This is a basic example of web scraping with Python and Beautiful Soup. Python and the Beautiful Soup library make it easy to perform web scraping, and can be used to extract data from a wide range of websites. There are many more advanced techniques and features available, such as handling pagination, handling AJAX requests, and handling cookies.

You can download the source code for this sample project here.

Python for Everyone: Mastering Python the Right Way

Janet Awino — Fri, 04 Mar 2022 21:57:23 +0000

Python is a sophisticated general-purpose programming language that is a great place to start learning how to program for beginners. Python features a basic, easy-to-understand syntax that is both concise and readable. Python is a powerful programming language that may be used for a wide range of applications including:

web development
software development
data analysis
machine learning
artificial intelligence

Here are the Python basics that will help you in mastering Python the right way!

Python Basics

1. Variables

Defining a variable and assigning a value to it is really simple in Python. Simply define a variable and then add an equal symbol = followed by the value you want to enter. Python variable writing has its own set of rules, which are as follows:

The first character must be a letter or an underscore.
The following characters can be letters, underscores, or numbers.
Variable names have case-sensitive characters. Lowercase and uppercase letters are distinguished in this way. For example, the variables myCourse and MyCourse are different variables. Code snippet for writing variables:

name = "Janet"
print(name)

2. Functions

A function is a code block that only executes when it is invoked. Parameters are data that can be passed into a function. As a result, a function can return data.

Creating a Function

The def keyword is used to declare a function in Python:

def bmi_calculator ():

Calling a Function

Use the function name followed by parenthesis to call it:

def bmi_calculator ():

bmi_calculator()

Arguments

Information can be passed into functions as arguments. Arguments are supplied inside parentheses after the function name. You can use as many arguments as you like; just use a comma to separate them. Here is the code snippet:

def bmi_calculator (name, height, weight):

3. Data Types

Variables can store a variety of data, and different types can perform different tasks. Python comes with the following data types pre-installed in these categories:

Text Type: str
Numeric Types: int, float
Sequence Types: list, tuple, range
Mapping Type: dict
Set Types: set, frozenset
Boolean Type: true, false

4. Conditionals

Conditionals are used to anticipate conditions that occur during the course of the program and determine what actions will be taken according to the conditions.
Conditions in Python include if, else and elif The if condition is used to execute code if the condition evaluates to True.
If the condition evaluates to False, the if statement/condition will not be executed.**
Below is an example of using the if condition in Python:

shoe = "Jordans"

if shoe == "Jordans":
    print("This is my favorite shoe")

5. Loops

Python has two primitive loop commands:
while loops
for loops

The while Loop

With the while loop we can execute a set of statements as long as a condition is true.

num = 5

  while num >= 1:
    print("*" * num)
    num -= 2

For Loops

A for loop is used for iterating over a sequence (that is either a list, a tuple, a dictionary, a set, or a string). With the for loop we can execute a set of statements, once for each item in a list, tuple, set etc.

for i in range(5):
    print(i)

6. Classes and Objects

Creating a class

The class statement is used to create a new class definition. The class name immediately follows the keyword class followed by a colon as follows.
class ClassName: 'Optional class documentation string' class_suite
Creating a class:

class MyClass:
  x = 5

Creating an Object

To instantiate a class, you call the class using the class name and pass any arguments that the init method accepts.
The code below shows how that can be achieved:

p1 = MyClass()
print(p1.x)

With the basics, I hope you can create and work with the most essential aspects of Python. Happy coding!

Introduction to Data Structures and Algorithms with Python

Janet Awino — Mon, 21 Feb 2022 15:50:12 +0000

In Computer Science, data structures and algorithms in Python are two of the most basic notions. For any programmer, they are essential tools. In Python, data structures are used to organize and store data in memory while a program is processing it. Python algorithms, on the other hand, are a set of instructions that aid in the processing of data for a certain purpose.

Data structures in Python

Data structures are a technique of organizing and storing information; they describe the relationship between data and the many logical operations that can be done on it. Data structures can be classified as either built-in Data-structures or user-defined data structures.

Built-in Data-structures:

The basic built-in data structures in Python include:

Lists
This is Python's most flexible data structure, represented as a list of comma-separated components enclosed in square brackets. Some of the methods applicable on a List are index(), append(), extend(), insert(), remove(), and pop(). Lists are changeable, which means that their content can be modified while maintaining their identity.

b = ["banana", "apple", "microsoft"]
print(b)

Output:

['banana', 'apple', 'microsoft']

Tuples
Tuples are similar to Lists, except that they are unchangeable and are declared within parentheses. In a Tuple once an element has been defined, it cannot be deleted or modified. It ensures that the data structure's specified values are neither tampered with or overridden.

my_tuple = (1, 2, 3)
print(my_tuple)

Output:

(1, 2, 3)

Dictionaries
Dictionaries consist of key-value pairs. The 'key' is used to identify an item, while the 'value' is used to store the item's value. The key and its value are separated by a colon. The items are separated by commas, and everything is encased in curly brackets. While keys cannot be changed, values can be of any type.

user = {
    "name" : "Janet",
    "age" : 22,
    "country" : "Kenya"
}

print(user["age"])

Output:

Sets
Sets are an unordered collection of unique elements. Sets, like Lists, are mutable and represented in square brackets, but they can't have the same value twice. Some methods that are applied on Sets include count(), index(), any(), and all().

myset = {1, 2, 3, 3, 1, 7,3, 6, 5, 4, 4}

print(myset)

Output:

{1, 2, 3, 4, 5, 6, 7}

User-defined Data-structures:

Stack

Stacks are linear data structures that work on the Last-In-First-Out (LIFO) principle, which means that data inserted last is the first to be accessed. It is constructed using an array structure and includes activities such as pushing (adding) elements, popping (deleting) elements, and only accessing elements from the TOP of the stack. This TOP is a pointer to the stack's current location. Recursive programming, reversing words, undo systems in word editors, are some of the applications that employ stacks extensively.

Linked List

Linked lists are linear Data Structures that are linked together via pointers rather than being stored sequentially. A linked list node is made up of data and a pointer named next. These structures are most commonly employed in image viewer, music player, and other applications.

Queue

A queue is a linear data structure based on the First-In-First-Out (FIFO) principle, which states that the data in first will be accessed first. It is constructed using an array structure and includes actions that can be performed from both the head and tail ends of the Queue, i.e., front-back and back-to-head. En-Queue and De-Queue operations are used to add and delete elements, and accessing the elements is possible. Queues are used as Network Buffers to manage traffic congestion, as well as Job Scheduling in Operating Systems.

Tree

Trees are non-linear Data Structures which have root and nodes. The root is the node from which the data comes, and the nodes are the other data points we have access to. The parent is the node that comes before the kid, and the child is the node that comes after it. A tree must have levels to demonstrate the depth of information. The leaves are the final nodes in a chain. Trees generate a hierarchy that can be utilized in a variety of real-world applications, such as identifying which tag belongs to which block in HTML pages. It's also useful for searching and a variety of other things.

Graph

Graphs are used to store data in the form of vertices (nodes) and edges (connections). The most accurate representation of a real-world map can be found in graphs. They are used to discover the least path by calculating the various cost-to-distance between the various data points known as nodes. Many programs, including Google Maps, Uber, and others, employ graphs to discover the shortest path and maximize earnings in the most efficient way possible.

HashMaps

In Python, HashMaps are the same as dictionaries. They may be used to create apps like phonebooks, populate data based on lists, and much more.

Algorithms

Algorithms are a set of rules or instructions written in a finite, sequential order to solve problems and provide the desired results. While data structures aid in data organization, algorithms aid in the solving of intractable data analysis problems.

In this article, we will discuss the following algorithms: Tree Traversal Algorithm, Sorting Algorithm, Searching Algorithm, and Graph Algorithm.

Tree Traversal Algorithms

Tree Traversal refers to visiting each node present in the tree exactly once in order to update or check them.

Searching Algorithm

Searching algorithms aid in the verification and retrieval of data elements from various data structures. One sort of searching algorithm is the sequential search approach, in which the list is traversed progressively and each member is checked. Examples of searching algorithms are:

Binary Search – The search interval is divided in half on a regular basis. The interval is narrowed to the lower half if the element to be searched is lower than the central component of the interval. It is narrowed to the upper half otherwise. The technique is continued until the desired result is obtained.
Linear Search– In this algorithm, each item is sequentially searched one by one.

Sorting Algorithm

Sorting algorithms denote the ways to arrange data in a particular format. Sorting ensures that data searching is optimized to a high level and that the data is presented in a readable format. Types of sorting algorithms in Python include: Bubble Sort, Merge Sort, Insertion Sort, Shell Sort, Selection Sort

Graph Algorithm

There are two methods of traversing graphs using their edges. These are:

Depth-first Traversal (DFS) – A graph is traversed in depth-ward motion in this algorithm. When an iteration comes to a halt, a stack is used to jump to the next vertex and begin the search. The set data types are used to implement DFS in Python.
Breadth-first Traversal (BFS) – A graph is traversed in a breadth-ward motion in this algorithm. When an iteration comes to a halt, a queue is used to advance to the next vertex and begin the search. The queue data structure is used to implement BFS in Python.

Python 101: Introduction to Modern Python

Janet Awino — Fri, 11 Feb 2022 16:06:31 +0000

What is Python?

Python is an interpreted, high-level programming language that was created in 1991 by Guido van Rossum, and is currently being maintained by the Python software foundation. It has a syntax that focuses on code readability thereby allowing beginners to get started easily and programmers to express their concepts in fewer lines of code.

What can Python do?

Python can be used:

On a server to create web applications.
In big data to perform complex mathematics.
For system scripting
For software development
In machine learning and artificial intelligence

Getting Started with Python

To start programming in Python on your local machine, open a terminal or command prompt and type the following command:

python --version

If Python is not installed on your local machine, download it here.
After installing python, run the above command to make sure Python is correctly installed.
If python is correctly installed you can go ahead and write your python program.

Writing your first Python program

You can either write and run Python code on the command prompt or create a Python file.
To write and run Python code on the command prompt, open the command prompt and type python. You will get output similar to this:

Python 3.10.2 (tags/v3.10.2:a58ebcc, Jan 17 2022, 14:12:15) [MSC v.1929 64 bit (AMD64)] on win32
Type "help", "copyright", "credits" or "license" for more information.
>>>

Here, type print("Hello Python!"). You will get output similar to this:

Hello Python!

Congratulations!!! You just wrote and run your first Python program on the command prompt.

To create a Python file and run the code, cd into the directory where you want to create the file using the Command Prompt and run the code below:

mkdir python_project && cd python_project 
touch HelloWorld.py
code .

The above instructions will create a folder named python_project and cd into the folder. The second command will create a file named HelloWorld.py. The last command will launch VS Code in our current folder.
If you do not have VS Code installed, you can download it from here.
After launching VS Code, open the HelloWorld.py file and type in the following code:

print("Hello Python!")

Launch the integrated terminal by pressing Ctrl + J. In the terminal, type python HelloWorld.py and hit Enter.
Congratulations on creating and running your first python file.

You can learn more about Python on the official documentation.