CodeWithDevops

Basic Design Pattern and Structure of C# Program using C# 13.0

2024-07-16T10:00:00.001+05:30

Today in this blog we are going to see how basic design of C# program looks like and what are the the codes that we need to write to run the program.

First thing is open Visual Studio application in your machine. If you don't know how to install click me to go through all steps and install properly so that if you follow my steps you should not get any errors or issues while running the application.

Step 1:- Open Visual Studio and Click on Create a new Project

Step 2:- Select Console application from all options and click next

Step 3:- Give any name you want and click next

Step 4:- Now click Create and don't do anything

Step 5:- My app name was TestApp so I am getting test app with green triangle just click on it, it will run and give you output on console that says Hello World.

Step 6:- Output will look like below on your console

I hope your app also is also getting same output, if not comment section is open you can ask any question will try to give you result as soon as possible.

Introduction of C# 13.0

2024-07-15T21:16:00.001+05:30

In this article we are going to start a series of C# language. This is not the first article on c# that you are going to see on the web, but I can promise you that this series is going to be different from every article and series that you will find on web.

What is C#?

C# is a programming language developed by Microsoft in early 2000.

It is Object Oriented Programming language mostly use to create web applications using dot net core or dot net.

Why C#?

C# has huge family of developers now a days. C# is actually very easy to learn and implemented language there in market which you can learn and start building applications.

C# is also putting their hand in Machine learning so basically you can think from here onwards level of this language.

If we talk about the performance of this language, it is enhanced and far better than it's competitors.

This is all about basic introduction of C#. We will continue learning this language in upcoming blogs and if you want to learn more, please do check my YouTube channel for in depth knowledge

Java Programming | A Complete Hands-on Guide

2023-09-25T13:54:00.000+05:30

An Introduction to Java Programming: Understanding the Basics with Examples

Java is one of the most widely used and versatile programming languages in the world. Known for its platform independence, robustness, and ease of use, Java has been a favorite among developers for decades. In this comprehensive introduction to Java programming, we'll explore the fundamental concepts of the language, provide practical examples, and help you get started on your journey to becoming a proficient Java developer.

What is Java?

Java is a high-level, object-oriented programming language developed by James Gosling and his team at Sun Microsystems (now owned by Oracle Corporation) in the mid-1990s. It was designed with the goal of creating a versatile language that could run on any platform, making it a "Write Once, Run Anywhere" language. This platform independence is achieved through the use of the Java Virtual Machine (JVM), which allows Java applications to execute on various operating systems without modification.

Setting Up Your Java Environment

Before we dive into writing Java code, let's set up our development environment. Here are the basic steps to get started:

1. Install the Java Development Kit (JDK):

The JDK is essential for developing and running Java programs. You can download the latest version of the JDK from Oracle's website or use an open-source alternative like OpenJDK. Make sure to choose the appropriate version for your operating system.

2. Choose a Code Editor or Integrated Development Environment (IDE):

While Java code can be written in a simple text editor, using a dedicated code editor or IDE can significantly enhance your productivity. Some popular options include Eclipse, IntelliJ IDEA, and Visual Studio Code with Java extensions. Pick the one that suits your preferences and install it.

3. Set Up Environment Variables (Optional):

To make it easier to compile and run Java code from the command line, you can set up the `JAVA_HOME` and `PATH` environment variables. These variables point to the location of your JDK installation. Consult your operating system's documentation for instructions on setting up environment variables.

This Can be yours first Java Program -

Now that you have your development environment ready, let's write your first Java program: the classic "Hello, World!" program. This program will simply display the text "Hello, World!" on the screen.

Open your code editor or IDE, create a new Java project or file, and enter the following code:


```java
public class HelloWorld {
    public static void main(String[] args) {
        System.out.println("Hello, World!");
    }
}
```

Here's a breakdown of what this code does:

- `public class HelloWorld`: This line defines a class named `HelloWorld`. In Java, every program is a class, and the name of the class must match the filename (including capitalization). A Java program must contain at least one class with a `main` method.

- `public static void main(String[] args)`: This line declares the `main` method. The `main` method is the entry point for your Java program, where execution begins. It takes an array of strings called `args` as its parameter, which allows you to pass command-line arguments to your program.

- `System.out.println("Hello, World!");`: This line uses the `System.out` object to print the text "Hello, World!" to the console. The `println` method adds a newline character after the text, so each `println` call displays its output on a new line.

~ Compiling and Running Your Java Program

Once you've written your Java program, it's time to compile and run it. Here's how you can do it:

1. Compilation:

In your code editor or IDE, navigate to the directory where your Java file is located. Open a terminal or command prompt in that directory and use the `javac` command to compile your program. For example:

```bash
javac HelloWorld.java
```

If there are no errors in your code, this command will generate a bytecode file named `HelloWorld.class`.

2. Execution:

To run your Java program, use the `java` command followed by the name of the class containing the `main` method (without the `.class` extension). For our "Hello, World!" program, you would run:

```bash
java HelloWorld
```

You should see the output "Hello, World!" displayed in the terminal.


  Congratulations! You've successfully written, compiled, and executed your
  first Java program. This simple example demonstrates the basic structure of a
  Java program, including the class declaration, the `main` method, and the use
  of the `System.out.println` statement.

Understanding Java Syntax

To become proficient in Java programming, it's essential to understand the language's syntax and conventions. Here are some key concepts:

1. Data Types:

Java supports various data types, including primitive data types like `int`, `double`, `boolean`, and `char`, as well as reference data types like classes and arrays. Here's a brief overview of primitive data types:

- `int`: Represents integers (whole numbers).

- `double`: Represents floating-point numbers (numbers with a decimal point).

- `boolean`: Represents a Boolean value (`true` or `false`).

- `char`: Represents a single character.

You can declare variables with these data types and assign values to them. For example:

```java

int age = 30;
double pi = 3.14159;
boolean isJavaFun = true;
char grade = 'A';
```

2. Variables and Declarations:

In Java, variables must be declared before they can be used. A variable declaration specifies the data type and name of the variable. Variable names are case-sensitive and should start with a letter, followed by letters, digits, or underscores. Here's an example:

```java
int count; // Declaration
count = 10; // Assignment
```

You can also declare and initialize variables in a single line:

```java
int score = 95; // Declaration and initialization
```

3. Operators:

Java supports various operators for performing operations on data. These include arithmetic operators (`+`, `-`, `*`, `/`, `%`), comparison operators (`==`, `!=`, `<`, `>`, `<=`, `>=`), and logical operators (`&&`, `||`, `!`), among others. Here are some examples:

```java
int x = 10;
int y = 5;
int sum = x + y; // Addition
int difference = x - y; // Subtraction
int product = x * y; // Multiplication
int quotient = x / y; // Division
int remainder = x % y; // Modulus
boolean isGreater = x > y; // Comparison
boolean isNotEqual = x != y;
boolean andResult = true && false; // Logical AND
boolean orResult = true || false; // Logical OR
boolean notResult = !true; // Logical NOT
```

4. Control Structures:

Java provides various control structures to manage the flow of your program. These include:

- Conditional Statements: `if`, `else if`, and `else` statements for making decisions based on conditions.

  ```java
  int number = 7;
  if (number > 0) {
      System.out.println("Number is positive");
  } else if (number < 0) {
      System.out.println("Number is negative");
  } else {
      System.out.println("Number is zero");
  }
  ```

- Loops: Java supports `for`, `while`, and `do-while` loops for repeating a set of statements.

  ```java
  // Using a for loop to print numbers from 1 to 5
  for (int i = 1; i <= 5; i++) {
      System.out.println(i);
  }
  // Using a while loop to find the sum of numbers from 1 to 1
  int sum = 0;
  int i = 1;
  while (i <= 10) {
      sum += i;
      i++;
  }
  // Using a do-while loop to validate user input
  Scanner scanner = new Scanner(System.in);
  int userInput;
  do {
      System.out.print("Enter a positive number: ");
      userInput = scanner.nextInt();
  } while (userInput <= 0);
  ```

- Switch Statement: A `switch` statement allows you to select one of many code blocks to be executed.

  ```java
  int dayOfWeek = 3;
  String dayName;
  switch (dayOfWeek) {
      case 1:
          dayName = "Monday";
          break;
      case 2:
          dayName = "Tuesday";
          break;
      case 3:
          dayName = "Wednesday";
          break;
      default:
          dayName = "Unknown";
  }
  ```

5. Methods:

Methods in Java are blocks of code that perform a specific task. They allow you to organize your code into reusable units. A method has a name, a return type (which can be `void` if it doesn't return a value), and a set of parameters (if needed). Here's an example of a simple method:

```java
public int add(int x, int y) {
    return x + y;
}
```
You can call this method elsewhere in your code to perform addition:
```java
int result = add(5, 3);
System.out.println(result); // Output: 8
```

6. Classes and Objects:

Java is an object-oriented programming language, which means it revolves around the concept of objects and classes. A class is a blueprint for creating objects, and objects are instances of classes. Here's a basic example:

```java
// Define a class
public class Dog {
    String name;
    int age;
    // Constructor
    public Dog(String name, int age) {
        this.name = name;
        this.age = age;
    }
    // Method to bark
    public void bark() {
        System.out.println(name + " says woof!");
    }
}
// Create objects of the class
Dog myDog = new Dog("Buddy", 3);
Dog anotherDog = new Dog("Rex", 5);
// Call methods on objects
myDog.bark(); // Output: Buddy says woof!
anotherDog.bark(); // Output: Rex says woof!
```

7. Inheritance:

Inheritance is a fundamental concept in object-oriented programming that allows you to create new classes (subclasses) based on existing classes (superclasses). Subclasses inherit properties and behaviors from their superclasses. Here's a simple example.

```java
// Superclass (Parent class)
class Vehicle {
    void start() {
        System.out.println("Starting the vehicle.");
    }
}
// Subclass (Child class)
class Car extends Vehicle {
    void drive() {
        System.out.println("Driving the car.");
    }
}
public class Main {
    public static void main(String[] args) {
        Car myCar = new Car();
        myCar.start(); // Inherited method
          myCar.drive(); // Method specific to Car class
    }
}
```

In this example, the `Car` class inherits the `start` method from the `Vehicle` class and adds its own `drive` method.

Common Java Programming Tasks

Now that we've covered the basics of Java syntax, let's explore some common programming tasks and how to accomplish them in Java.

Input and Output

Java provides various ways to handle input and output operations. One common approach is to use the `Scanner` class for reading input from the user and the `System.out` object for printing output. Here's an example of reading user input and displaying it:

```java
import java.util.Scanner;
public class InputOutputExample {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        // Read user input
        System.out.print("Enter your name: ");
        String name = scanner.nextLine();
        // Display a message
        System.out.println("Hello, " + name + "!");
        // Close the scanner
        scanner.close();
    }
}
```

Arrays

Arrays are used to store collections of elements of the same data type. In Java, arrays are zero-indexed, which means the first element is at index 0. Here's an example of creating and using an array:

```java
public class ArrayExample {
    public static void main(String[] args) {

          // Declare and initialize an array of integers
        int[] numbers = { 1, 2, 3, 4, 5 };

        // Access elements by index
        int firstNumber = numbers[0]; // 1
        int thirdNumber = numbers[2]; // 3
        // Calculate the length of the array
        int length = numbers.length; // 5
        // Loop through the array
        for (int i = 0; i < numbers.length; i++) {
            System.out.println(numbers[i]);
        }
    }
}
```

Exception Handling

In Java, exceptions are used to handle unexpected events or errors that can occur during program execution. You can use try-catch blocks to handle exceptions gracefully. Here's an example:

```java
public class ExceptionHandlingExample {
    public static void main(String[] args) {
        try {
            // Attempt to divide by zero
            int result = 10 / 0;
        } catch (ArithmeticException e) {
            // Handle the exception

              System.err.println("An error
  occurred: " + e.getMessage());

        }
    }
}
```

In this example, an `ArithmeticException` is caught when attempting to divide by zero, and an error message is printed.

File Handling

Java provides classes like `File`, `FileInputStream`, and `FileOutputStream` for reading from and writing to files. Here's a basic example of reading and writing to a text file:

```java
import java.io.*;
public class FileHandlingExample {
    public static void main(String[] args) {
        // Writing to a file
          try (FileOutputStream fos = new
  FileOutputStream("sample.txt")) {

              String message = "Hello, file!";
            fos.write(message.getBytes());
        } catch (IOException e) {
            e.printStackTrace();
        }
        // Reading from a file
          try (FileInputStream fis = new
  FileInputStream("sample.txt")) {
            int data;

              while ((data = fis.read()) != -1) {
                 
  System.out.print((char) data);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}
```

This code writes the "Hello, file!" message to a file named `sample.txt`

and then reads and prints the contents of the file.

Resources for Learning Java

Learning Java is a rewarding journey, and there are plenty of resources available to help you become a proficient Java developer. Here are some recommended resources to continue your Java education:

Books

1. "Effective Java" by Joshua Bloch: A must-read for Java developers, this book provides best practices and design patterns for writing high-quality Java code.

2. "Java: The Complete Reference" by Herbert Schildt: A comprehensive guide to Java, covering everything from basic concepts to advanced topics.

3. "Head First Java" by Kathy Sierra and Bert Bates: Known for its engaging and beginner-friendly approach to teaching Java.

Online Courses

1. Coursera's "Java Programming and Software Engineering Fundamentals": Offered by Duke University, this course is an excellent introduction to Java and software development.

2. edX's "Java Programming and Software Engineering Fundamentals": Another well-structured course, this one is offered by Microsoft.

3. Codecademy's Java Course: A free online course that covers Java fundamentals and provides hands-on coding exercises.

Java Development Communities

1. Stack Overflow: A vibrant community of developers where you can ask questions, find answers, and learn from others' experiences.

2. GitHub: Explore Java projects, contribute to open-source projects, and collaborate with other developers.

Documentation and Tutorials

1. Oracle's Java Documentation: The official Java documentation is an invaluable resource for understanding Java's standard libraries and APIs.

2. Java Tutorials by Oracle: A series of tutorials provided by Oracle to help you learn Java step by step.

Practice Coding

1. LeetCode: A platform for practicing coding problems, including a variety of Java challenges.

2. HackerRank: Offers a collection of Java coding challenges and competitions to improve your skills.

Conclusion

Java is a powerful, versatile, and widely-used programming language that has stood the test of time. In this introduction, we've covered the basics of Java syntax, common programming tasks, and provided resources to help you continue your Java learning journey. Whether you're a beginner taking your first steps in coding or an experienced developer looking to add Java to your skill set, mastering Java can open up a world of possibilities for you in the world of software development. So, start coding and exploring the endless possibilities that Java has to offer!

How to make Connection in Java JDBC with MySQL

2022-05-06T10:53:00.005+05:30

Java is one the most used language today. More than 10 million people use java for development.

To connect database to our java applications we generally use JDBC. JDBC stands for Java Database Connectivity.

To connect JDBC to MySQL we need MySQL connector, you can download this from MySQL website.

After downloading extract file and copy the jar file. Now open any IDE to code your java, and create a new project then create a directory and paste the JDBC jar file that you downloaded from MySQL and create new file and start typing code:

import java.sql.*;
public class MyJDBC {
    public static void main(String[] args) {
        try {
            Connection connection = DriverManager.getConnection("jdbc:mysql://localhost:3306/sakila", "root", "aakash");
            Statement statement = connection.createStatement();
            ResultSet resultSet = statement.executeQuery("select * from actor");
            while (resultSet.next()) {
                System.out.println(resultSet.getString("first_name"));
            }
        }
        catch(Exception e) {
            e.printStackTrace();
        }
    }
}

As you can see the above code, first thing is to import library of sql to our java program.

After importing library of sql create a class and a main method in which you will write codes.

Before going ahead you should know that to connect database to our java program you have to go through 3 processes, these are:-

1. Connection

2. Statement

3. ResultSet

Connection will track your sql files and help in running your code.

Statement will make connection to your database and try to connect the database.

ResultSet will execute the query which will be given to it.

After these processes we call a while loop to trace the every element of the query and print them.

Now you are good to go but good practice to connect a database is to code in try and catch statement, so keep your code in try and catch.

Now you are done! Run the program and you will get your solution.

In my case Output will be:

PENELOPE
NICK
ED
JENNIFER
JOHNNY
BETTE
GRACE
MATTHEW
JOE
CHRISTIAN
ZERO
KARL
UMA
VIVIEN
CUBA
FRED
HELEN
DAN
BOB
LUCILLE
KIRSTEN
ELVIS
SANDRA
CAMERON
KEVIN
RIP
JULIA
WOODY
ALEC
SANDRA
SISSY
TIM
MILLA
AUDREY
JUDY
BURT
VAL
TOM
GOLDIE
JOHNNY
JODIE
TOM
KIRK
NICK
REESE
PARKER
JULIA
FRANCES
ANNE
NATALIE
GARY
CARMEN
MENA
PENELOPE
FAY
DAN
JUDE
CHRISTIAN
DUSTIN
HENRY
CHRISTIAN
JAYNE
CAMERON
RAY
ANGELA
MARY
JESSICA
RIP
KENNETH
MICHELLE
ADAM
SEAN
GARY
MILLA
BURT
ANGELINA
CARY
GROUCHO
MAE
RALPH
SCARLETT
WOODY
BEN
JAMES
MINNIE
GREG
SPENCER
KENNETH
CHARLIZE
SEAN
CHRISTOPHER
KIRSTEN
ELLEN
KENNETH
DARYL
GENE
MEG
CHRIS
JIM
SPENCER
SUSAN
WALTER
MATTHEW
PENELOPE
SIDNEY
GROUCHO
GINA
WARREN
SYLVESTER
SUSAN
CAMERON
RUSSELL
MORGAN
MORGAN
HARRISON
DAN
RENEE
CUBA
WARREN
PENELOPE
LIZA
SALMA
JULIANNE
SCARLETT
ALBERT
FRANCES
KEVIN
CATE
DARYL
GRETA
JANE
ADAM
RICHARD
GENE
RITA
ED
MORGAN
LUCILLE
EWAN
WHOOPI
CATE
JADA
RIVER
ANGELA
KIM
ALBERT
FAY
EMILY
RUSSELL
JAYNE
GEOFFREY
BEN
MINNIE
MERYL
IAN
FAY
GRETA
VIVIEN
LAURA
CHRIS
HARVEY
OPRAH
CHRISTOPHER
HUMPHREY
AL
NICK
LAURENCE
WILL
KENNETH
MENA
OLYMPIA
GROUCHO
ALAN
MICHAEL
WILLIAM
JON
GENE
LISA
ED
JEFF
MATTHEW
DEBBIE
RUSSELL
HUMPHREY
MICHAEL
JULIA
RENEE
ROCK
CUBA
AUDREY
GREGORY
JOHN
BURT
MERYL
JAYNE
BELA
REESE
MARY
JULIA
THORA

Add Two Numbers (LeetCode Problems)

2022-04-30T09:50:00.004+05:30

Today you will learn about one more problem of leetcode i.e. add two number.

In this problem you have given two linked list with reversed order numbers, you have to add two numbers from the linked list and return them as sum.

For example: [3,4,2][4,6,5] => [8,0,7] so in question you have asked for reverse order so it will be [7,0,8] as sum of number.

Let's solve this problem:-

class ListNode:
    def __init__(self, val=0, next=None):
        self.val = val
        self.next = next
class Solution:
    def addTwoNumbers(self, l1: Optional[ListNode], l2: Optional[ListNode]) -> Optional[ListNode]:
        result = ListNode(0)
        result_tail = result
        carry = 0           
        while l1 or l2 or carry:            
            val1  = (l1.val if l1 else 0)
            val2  = (l2.val if l2 else 0)
            carry, out = divmod(val1+val2 + carry, 10)            
            result_tail.next = ListNode(out)
            result_tail = result_tail.
            l1 = (l1.next if l1 else None)
            l2 = (l2.next if l2 else None)
        return result.next

First thing is that we have created a class which is collecting all the nodes(Values).

After that in second class, we are adding the numbers and returning to the class.

This is medium level question but quite easy it was!

We will meet with another questions till then enjoy Coding!

Two Sum (LeetCode Problem)

2022-04-27T20:03:00.006+05:30

Every programmer want to compete with each other and each other means every other coder who is stronger than other.

Beginners do one big mistake, they open any platform like LeetCode, HackerRank or HackerEarth and think that they can become champion is 1 days.

To start these platforms you should have two basic understanding:

One is Knowledge About Any One Programming Language.

Second is you have at least Basic Knowledge of Data Structures.

After the basic knowledge you can start your problem solving journey. This is first blog on problem solving, will come tons of more ahead so you should be able to understand solutions very easily.

First step to this competitive programming is to stick with one platform and have knowledge about basics.

Second step is open problem and try to understand that problem.

Third step is write pseudo code on notebook that how you are going to solve that problem.

Fourth step is Write code and try to figure out each cases.

Now, lets get in to our problem i.e. Two Sum.

Note:- Problem's solution will be in Python.

In this problem you have given an array and a target value, your task is search in your array and find two numbers whose sum will be the target.

So, lets start coding:-

class Solution:
    def twoSum(self, nums: List[int], target: int) -> List[int]:
        size = len(nums)
        for i in range(size):
            for j in range(i+1, size):
                if nums[j] == target - nums[i]:
                    return [i,j]

This is the solution of this problem let's understand each line, First solution class is

created for this line you have at least basic knowledge of OOPs.

Then twoSum method is created and in that array and target is passed.

After that size of array is calculated and stored in variable named size.

Then a for loop is used in range of size(means it will perform on size of the variable), then inner

loop is created from one size incremented from first to same length of loop.

Then checking if second number is equal to target - first or not, if equal print both numbers.

And Booyah! you get the solution, it was too easy write.

Introduction to MySQL(Database)

2022-04-25T20:00:00.002+05:30

What is database?

It is a collection of data.
A method for accessing and manipulating that data.
A structured set of computerized data with an accessible interface.

Difference between database and database management system:-

Database is a gigantic collection of data.
DBMS allows to interact with database.

Difference between SQL and MySQL:-

SQL stands for Structured Query Language. SQL is the language we use

to "talk" to our databases(Insert, Delete, Update, etc...). Working

with MySQL is primarily writing SQL.

There are n numbers of Relational Databases(RDBMS) who uses SQL:

MySQL
SQLite
PostgreSQL
Oracle
Many Others

MySQL Commands:-

show databases;

This commands will show you total databases present in your database.

for example:

mysql> show databases;

+--------------------+

| Database |

+--------------------+

| information_schema |

| mysql |

| performance_schema |

| sakila |

| sys |

| world |

+--------------------+

6 rows in set (0.00 sec)

SELECT database;

SELECT is used to retrieve rows selected from one or more tables, and

can include UNION statements and subqueries. See [HELP UNION], and

https://dev.mysql.com/doc/refman/8.0/en/subqueries.html. A SELECT

statement can start with a WITH clause to define common table

expressions accessible within the SELECT. See

https://dev.mysql.com/doc/refman/8.0/en/with.html.

The most commonly used clauses of SELECT statements are these:

o Each select_expr indicates a column that you want to retrieve. There

must be at least one select_expr.

o table_references indicates the table or tables from which to retrieve

rows. Its syntax is described in [HELP JOIN].

o SELECT supports explicit partition selection using the PARTITION

clause with a list of partitions or subpartitions (or both) following

the name of the table in a table_reference (see [HELP JOIN]). In this

case, rows are selected only from the partitions listed, and any

other partitions of the table are ignored. For more information and

examples, see

https://dev.mysql.com/doc/refman/8.0/en/partitioning-selection.html.

o The WHERE clause, if given, indicates the condition or conditions

that rows must satisfy to be selected. where_condition is an

expression that evaluates to true for each row to be selected. The

statement selects all rows if there is no WHERE clause.

In the WHERE expression, you can use any of the functions and

operators that MySQL supports, except for aggregate (group)

functions. See

https://dev.mysql.com/doc/refman/8.0/en/expressions.html, and

https://dev.mysql.com/doc/refman/8.0/en/functions.html.

SELECT can also be used to retrieve rows computed without reference to

any table.

URL: https://dev.mysql.com/doc/refman/8.0/en/select.html

> select @@hostname;

This command tells the hostname i.e. username of your database. For example:

mysql> select @@hostname;

+------------+

| @@hostname |

+------------+

| Aakash |

+------------+

1 row in set (0.00 sec)

mysql> CREATE DATABASE Aakash;

Query OK, 1 row affected (0.03 sec)

CREATE DATABASE creates a database with the given name. To use this

statement, you need the CREATE privilege for the database. CREATE

SCHEMA is a synonym for CREATE DATABASE.

Deleting Database:-

Syntax:

DROP {DATABASE | SCHEMA} [IF EXISTS] db_name

Example:

mysql> DROP DATABASE aakash;

Query OK, 0 rows affected (0.08 sec)

DROP DATABASE drops all tables in the database and deletes the

database. Be very careful with this statement! To use DROP DATABASE,

you need the DROP privilege on the database. DROP SCHEMA is a synonym

for DROP DATABASE.

Note:-

When a database is dropped, privileges granted specifically for the

database are not automatically dropped. They must be dropped manually.

See [HELP GRANT].

IF EXISTS is used to prevent an error from occurring if the database

does not exist.

Select a database to use:-

Syntax:

USE db_name

Example:

mysql> use my_db;

Database changed

The USE statement tells MySQL to use the named database as the default

(current) database for subsequent statements. This statement requires

some privilege for the database or some object within it.

The named database remains the default until the end of the session or

another USE statement is issued:

USE db1;

SELECT COUNT(*) FROM mytable; # selects from db1.mytable

USE db2;

SELECT COUNT(*) FROM mytable; # selects from db2.mytable

The database name must be specified on a single line. Newlines in

database names are not supported.

mysql> select database();

+------------+

| database() |

+------------+

| my_db |

+------------+

1 row in set (0.00 sec)

This command tells about the database which is currently using.

If you delete your current working database then run this command to lookout your database you will find empty database.

mysql> select database();

+------------+

| database() |

+------------+

| NULL |

+------------+

1 row in set (0.00 sec)

Tables:-

A database is just a bunch of tables.

TABLE is a DML(Data Manipulation Language) statement introduced in MySQL 8.0.19 which returns rows

and columns of the named table.

Syntax:

TABLE table_name [ORDER BY column_name] [LIMIT number [OFFSET number]]

The TABLE statement in some ways acts like SELECT. Given the existance

of a table named t, the following two statements produce identical

output:

TABLE t;

SELECT * FROM t;

TABLE differs from SELECT in two key respects:

o TABLE always displays all columns of the table.

o TABLE does not allow for any arbitrary filtering of rows; that is,

TABLE does not support any WHERE clause.

For limiting which table columns are returned, filtering rows beyond

what can be accomplished using ORDER BY and LIMIT, or both, use SELECT.

TABLE can be used with temporary tables.

URL: https://dev.mysql.com/doc/refman/8.0/en/table.html

Data Types:-

AUTO_INCREMENT
BIGINT
BINARY
BIT
BLOB
BLOB DATA TYPE
BOOLEAN
CHAR
CHAR BYTE
DATE
DATETIME
DEC
DECIMAL
DOUBLE
DOUBLE PRECISION
ENUM
FLOAT
INT
INTEGER
LONGBLOB
LONGTEXT
MEDIUMBLOB
MEDIUMINT
MEDIUMTEXT
SET DATA TYPE
SMALLINT
TEXT
TIME
TIMESTAMP
TINYBLOB
TINYINT
TINYTEXT
VARBINARY
VARCHAR
YEAR DATA TYPE

Creating Table:-

Note:- Table name must be pluralized

CREATE TABLE creates a table with the given name. You must have the

CREATE privilege for the table.

By default, tables are created in the default database, using the

InnoDB storage engine. An error occurs if the table exists, if there is

no default database, or if the database does not exist.

MySQL has no limit on the number of tables. The underlying file system

may have a limit on the number of files that represent tables.

Individual storage engines may impose engine-specific constraints.

InnoDB permits up to 4 billion tables.

Example:

mysql> CREATE TABLE cats (

-> name VARCHAR(100),

-> age INT

-> );

Query OK, 0 rows affected (0.11 sec)

This is how you will create database, don't think much about spaces it does not matter at all. for readability I write this way you can choose your one.

Now we have created table but how to check?

mysql> show tables;

+-----------------------------+

| Tables_in_cats_janamkundali |

+-----------------------------+

| cats |

+-----------------------------+

1 row in set (0.04 sec)

This is one way to find your table.

mysql> show columns from cats;

+-------+--------------+------+-----+---------+-------+

+-------+--------------+------+-----+---------+-------+

| age | int | YES | | NULL | |

+-------+--------------+------+-----+---------+-------+

2 rows in set (0.05 sec)

This is another way to access the table.

mysql> DESC cats;

+-------+--------------+------+-----+---------+-------+

+-------+--------------+------+-----+---------+-------+

| age | int | YES | | NULL | |

+-------+--------------+------+-----+---------+-------+

2 rows in set (0.04 sec)

This is also the same as above but more short and easy to understand.

Deleting Tables:-

Syntax:

DROP [TEMPORARY] TABLE [IF EXISTS]

tbl_name [, tbl_name] ...

[RESTRICT | CASCADE]

DROP TABLE removes one or more tables. You must have the DROP privilege

for each table.

Be careful with this statement! For each table, it removes the table

definition and all table data. If the table is partitioned, the

statement removes the table definition, all its partitions, all data

stored in those partitions, and all partition definitions associated

with the dropped table.

Dropping a table also drops any triggers for the table.

DROP TABLE causes an implicit commit, except when used with the

TEMPORARY keyword. See

https://dev.mysql.com/doc/refman/8.0/en/implicit-commit.html.

Note:-

When a table is dropped, privileges granted specifically for the table

are not automatically dropped. They must be dropped manually. See [HELP

GRANT].

If any tables named in the argument list do not exist, DROP TABLE

behavior depends on whether the IF EXISTS clause is given:

o Without IF EXISTS, the statement fails with an error indicating which

nonexisting tables it was unable to drop, and no changes are made.

o With IF EXISTS, no error occurs for nonexisting tables. The statement

drops all named tables that do exist, and generates a NOTE diagnostic

for each nonexistent table. These notes can be displayed with SHOW

WARNINGS. See [HELP SHOW WARNINGS].

IF EXISTS can also be useful for dropping tables in unusual

circumstances under which there is an entry in the data dictionary but

no table managed by the storage engine. (For example, if an abnormal

server exit occurs after removal of the table from the storage engine

but before removal of the data dictionary entry.)

The TEMPORARY keyword has the following effects:

o The statement drops only TEMPORARY tables.

o The statement does not cause an implicit commit.

o No access rights are checked. A TEMPORARY table is visible only with

the session that created it, so no check is necessary.

Including the TEMPORARY keyword is a good way to prevent accidentally

dropping non-TEMPORARY tables.

The RESTRICT and CASCADE keywords do nothing. They are permitted to

make porting easier from other database systems.

DROP TABLE is not supported with all innodb_force_recovery settings.

See

https://dev.mysql.com/doc/refman/8.0/en/forcing-innodb-recovery.html.

URL: https://dev.mysql.com/doc/refman/8.0/en/drop-table.html

Example:

mysql> drop table cats;

Query OK, 0 rows affected (0.07 sec)

To check you can use above methods or commands:

mysql> show tables;

Empty set (0.00 sec)

If you want more briefs about each queries then in MySQL command type help WHAT_YOU_WANT_TO_KNOW and enter you will get brief about your topic.

Most of them were from there only in this blog so you can get genuine definitions.

Linked List with Python

2022-03-31T12:08:00.002+05:30

In programming world there is a concept of arrays, they help out our most of problems without any hurdles.

But you have to accept that some problems are very big and not tolerable also. One of the biggest problem is memory management.

Let's understand this memory management concept first.

Whatever thing you store in your memory is store in binary forms and you don't know where these data are stored, then array concept came in to action and made life easier of programmers.

You may ask how?

Let me clarify you, In other programming languages arrays can store only one data type at one time let's leave them and focus on Python.

In Python List is use on behalf of arrays(you can say it Dynamic Arrays).

One can store n numbers of data inside these dynamic arrays but there is memory management problem.

Array works like:- If you create an array you have to give size of it so let's consider 5 is size. If you want to store more values you have to create another array right? This was Static array now to solve this issue Dynamic Array introduced, it was able to solve this problem i.e. you don't have to give size of an array and if you stored 10 values in it and further after some time you want to enter 2 more values so your array will copy the data and make an array of double size then previous (previous was of size 10, now it will create size of 20 array) and paste previous values and next 2 values. But as you can see 8 boxes in arrays are empty means our memory is wasting and previous array is not deleted it is also stored in memory.

After this big issue solution came with Linked List. Linked List does not store values in arrays it take values with next address of data and keep the address to find them.

Head position of Linked List is always pointing to None you cannot fill any values there.

Linked List connected with nodes means each value is joined with next one's address.

Linked List is having one more type i.e. Double Linked List some people says Doubly Linked List whatever you want it is your choice.

Double Linked List is same as linked list but one difference is that it store data, previous and next data's address to keep in touch with them(to access them).

Let's understand Linked List with an example:-

class Node:
    def __init__(self, data=None, next=None):
        self.data = data
        self.next = next

class LinkedList:
    def __init__(self):
        self.head = None
    def insert_at_beginning(self, data):
        node = Node(data, self.head)
        self.head = node
    def print(self):
        if self.head is None:
            print("Linked List is empty")
            return
        itr = self.head
        linkstr = ""
        while itr:
              linkstr += str(itr.data) + "==>"
            itr = itr.next
        print(linkstr)
    def insert_at_end(self, data):
        if self.head is None:
            self.head = Node(data, None)
            return
        itr = self.head
        while itr.next:
            itr = itr.next
        itr.next = Node(data,None)
    def lengh_of_linkedlist(self):
        count = 0
        itr = self.head
        while itr:
            count += 1
            itr = itr.next
        return count
if __name__ == "__main__":
    Llist = LinkedList()
    Llist.insert_at_beginning(8)
    Llist.insert_at_beginning(18)
    Llist.insert_at_beginning(12)
    Llist.insert_at_end(1)
    Llist.insert_at_end(111)
    Llist.insert_at_end(110)
    Llist.print()
   print("Length of this Linked List is:",Llist.lengh_of_linkedlist())

In above program as you can see there are 2 classes, first one is Node and another is LinkedList. In node class data and next variable is created to create data for linked list. In class LinkedList firstly head is initialized with None because as above you read that head should always be pointing to None. After that insert_at_beginning method is created to store values in beginning of Linked List. Then print method is created to print the linked list also you can see insert_at_end method is there to store values from last side of Linked List. After that lengh_of_linkedlist method is created to check the length of the Linked List. At last main functon is there in which object of LinkedList is created and all methods are called with the help of that object.

Output is:-

12==>18==>8==>1==>111==>110==>
Length of this Linked List is: 6

Queue Data Structure with Python

2022-03-29T11:37:00.004+05:30

Queue data structure can be understand by railway ticket lines, whom come first will get ticket first.

Queue can be defined as a data structure in which the first element entered inside an array or a list will be removed first.

Let's try to understand with an example:-


print("Welcome to codewithdevops.")

  print("Hit enter to input next item, enter r to remove and q to quit.")


queue = []

while True:

   data = input("Enter the element: ")


 if str.lower(data) == "q":

   print("Breaking the loop....")

 break

 elif str.lower(data) == "r":

   print("Removing:",queue.pop(0))


 else:
 queue.append(data)
 print(queue)
]
for item in queue:
 print("You entered:",item)

In this example you have to focus what is happening, first you can see a statement trying to simplyfy functions for you, then empty queue is created. for those functions a loop is working to give functions. that's it.

Here is an output of the program:-


Welcome to codewithdevops.
Hit enter to input next item, enter r to remove and q to quit.
Enter the element: 12
['12']
Enter the element: 23
['12', '23']
Enter the element: 34
['12', '23', '34']
Enter the element: 45
['12', '23', '34', '45']
Enter the element: 56
['12', '23', '34', '45', '56']
Enter the element: r
Removing: 12
['23', '34', '45', '56']
Enter the element: r
Removing: 23
['34', '45', '56']
Enter the element: r
Removing: 34
['45', '56']
Enter the element: r
Removing: 45
['56']
Enter the element: q
Breaking the loop....
You entered: 56

Above example is quite simple and easy to understand things very easily. Let's make that example much more functional and good looking.

queue = []
def enqueue():
    while True:

          print("Select numbers according your element to
  put in queue: ")

          print("1.Int 2.Float 3.String 4.Bool 0.Quit")

          choice_queue = int(input("Enter your choice: "))

        if choice_queue == 1:
              queue_element = int(input("Enter
  your integer value: "))

            queue.append(queue_element)

              print(queue_element,"is added to
  queue")

        elif choice_queue == 2:
              queue_element = float(input("Enter
  your float value: "))

            queue.append(queue_element)

              print(queue_element,"is added to
  queue")

        elif choice_queue == 3:
              queue_element = input("enter the
  element: ")

            queue.append(queue_element)

              print(queue_element,"is added to
  queue")

        elif choice_queue == 4:
              queue_element = int(input("enter the
  element: "))

            if queue_element < 1:
                  queue.append(False)

                  print(False,"is added
  to queue")

            elif queue_element >= 1:
                  queue.append(True)

                  print(True,"is added
  to queue")

        elif choice_queue == 0:
            break

        else:
              print("Enter the correct option..")

    
def dequeue():
    if not queue:
        print("queue is empty.")
    else:
        e = queue.pop(0)

        print("Removed element",e)

def display():
    print(queue)

while True:
    print("Welcome to CodeWithDevops!")
    print("Today you will see the queue Data Structure...")

    print("Select the operation 1.add 2.remove 3.show 4.quit")
    choice = int(input("Enter your choice: "))
    if choice == 1:
        enqueue()
    elif choice == 2:
        dequeue()
    elif choice == 3:
        display()
    elif choice == 4:
        break
    else:
        print("Enter the correct operation..")

If you look in this program each and every thing is functioning same but code is totally changed.

Output is:-


Welcome to CodeWithDevops!
Today you will see the queue Data Structure...
Select the operation 1.add 2.remove 3.show 4.quit
Enter your choice: 1
Select numbers according your element to put in queue:
1.Int 2.Float 3.String 4.Bool 0.Quit
Enter your choice: 1
Enter your integer value: 12
12 is added to queue
Select numbers according your element to put in queue:
1.Int 2.Float 3.String 4.Bool 0.Quit
Enter your choice: 2
Enter your float value: 21
21.0 is added to queue
Select numbers according your element to put in queue:
1.Int 2.Float 3.String 4.Bool 0.Quit
Enter your choice: 3
enter the element: CodeWithDevops
CodeWithDevops is added to queue
Select numbers according your element to put in queue:
1.Int 2.Float 3.String 4.Bool 0.Quit
Enter your choice: 4
enter the element: 1
True is added to queue
Select numbers according your element to put in queue:
1.Int 2.Float 3.String 4.Bool 0.Quit
Enter your choice: 0
Welcome to CodeWithDevops!
Today you will see the queue Data Structure...
Select the operation 1.add 2.remove 3.show 4.quit
Enter your choice: 3
[12, 21.0, 'CodeWithDevops', True]
Welcome to CodeWithDevops!
Today you will see the queue Data Structure...
Select the operation 1.add 2.remove 3.show 4.quit
Enter your choice: 2
Removed element 12
Welcome to CodeWithDevops!
Today you will see the queue Data Structure...
Select the operation 1.add 2.remove 3.show 4.quit
Enter your choice: 2
Removed element 21.0
Welcome to CodeWithDevops!
Today you will see the queue Data Structure...
Select the operation 1.add 2.remove 3.show 4.quit
Enter your choice: 2
Removed element CodeWithDevops
Welcome to CodeWithDevops!
Today you will see the queue Data Structure...
Select the operation 1.add 2.remove 3.show 4.quit
Enter your choice: 2
Removed element True
Welcome to CodeWithDevops!
Today you will see the queue Data Structure...
Select the operation 1.add 2.remove 3.show 4.quit
Enter your choice: 2
queue is empty.
Welcome to CodeWithDevops!
Today you will see the queue Data Structure...
Select the operation 1.add 2.remove 3.show 4.quit
Enter your choice: 4

There is a module in Python named as collections if you import it in your program it provides you much more functionality.

In below program you will be introduced with deque() method that works same as queue.

import collections

queue = collections.deque()
queue.appendleft(10)
queue.appendleft(20)
queue.appendleft(30)

print(queue)

print(queue.pop())

Above program have soe changes like appendleft() method, this method add values to the left side of list.

Output is:-


deque([30, 20, 10])
10

There is one more way to solve queue data structure i.e. queue module.


import queue

a = queue.Queue()
a.put(10)
a.put(20)
a.put(30)
a.put(40)
a.put(50)

print(a)
print(a.get())
print(a.get())
print(a.get())

Here you can see that after importing queue module you get 2 more methods i.e. put and get. They are similar to append and pop so no need of explanation to them.

Output is:-

<queue.Queue object at 0x000001F160357FD0>
10
20
30

Kruskal's Algorithm

2022-03-29T02:00:00.000+05:30

If you're a Computer Science Student or willing to be a; you'll definitely come through this Kruskal and many other Algorithm. In a Simple Language, Kruskal's Algorithm is a Minimum Spanning Tree Algorithm that gets a graph as input and retrieve the subset of the edges of that respective graph and which ahead forms a tree that include every vertex which has minimum sum of weightage among all of the trees that can be formed through a graph.

This Kruskal's Algorithm works as a detector and finds a minimum spanning forest of an undirected edge-weightage graph.

Consider, If a Graph is connected, it finds a minimum spanning tree.

In this article, we'll also discuss the following elements like complexity, working, few examples and proper implementation of Kruskal's Algorithm.

But, I would like to make pause here and recommend you to first understand the basic terms such as Spanning Tree and Min. Spanning Tree.

Spanning Tree - Spanning Tree is the subgraph of a connected graph (i.e. undirected).

Minimum Spanning Tree - It can be defined as the spanning tree in which the sum of all weightage of all edge would or is Minimum.

Now, Let's Start with the Main Topic:

What is Kruskal's Algorithm?

Answer - Kruskal's Algorithm is used to retrieve the minimum spanning tree for a a connected weighted graph.

The Main Aim of this Algorithm is to find the Subset of all edges by using the method of which we can traverse each vertex of the respective graph.

This Kruskal Algorithm follows the Greedy Method by which it can find the optimum solution at each level.

Applications of Kruskal's Algorithm -

It can be used to lay down LAN (Local Area Network) Connections.
It can be used to layout electrical wiring among larger distanced cities.

Working of Kruskal's Algorithm -

In Kruskal's Algorithm, we start our execution from edges with the lowest weight and keep increasing or adding the edges until the final goal is achieved.

Complexity of Kruskal's Algorithm -

Here there's a Time Complexity in Kruskal's Algorithm, Let's See.

Time Complexity - of Kruskal's Algorithm is O(E logE) or O(V logV), where V is only the Number of Vertices, and E is Number of Edges.

Here are the Following Steps for Solving Kruskal's Algorithm:

Start Sorting all the Edges from Low Weightage to High-One.
Now, take the Edge with Lowest Volume or Weightage and keep adding it to the spanning tree. If the Edge, starts creating a loop or cycle then reject the edge.
Continue to add the the edges until and unless you reach all the vertices and until the minimum spanning tree is built or created.

Let's take an Example to Solve - It will become easier to understand using an example. Let's see an example. Go!

Consider, a Weightage Graph is:

All the Readings of the diagram are given below.

Now, Let's sort the edges provided above in the ascending order according to their weights.

Now, Let's Start the Building Process or Constructing a Minimum Spanning Tree.

Tip - While Formation, Do Reject or Discard the Edges which are creating Loop/Cycle.

Step-by-Step Procedure:

Step 1 - First, add the Edge AB with weight 1 to the MST (Minimum Spanning Tree).

Step 2 - Now, Add the Edge DE with weight 2 to the MST (Minimum Spanning Tree) as it's not creating the Cycle.

Note: MST stands for 'Minimum Spanning Tree'

Step 3 - Add the Edge BC with weight 3 to the MST, as it's not forming cycle or a loop.

Step 4 - Now, Pick the Edge CD with Weight 4 to the MST, as it's not forming the loop/cycle.

Step 5 - Then, go for the edge AE with weight 5. I think, In my Opinion, this will create a loop/cycle, then it's better to discard it.

Step 6 - Pick the Edge AC with weight 7. This will also create a cycle or loop so we need to discard it.

Step 7 - Pick the Edge AD with weight 10. Same, this will also create a loop in MST, so Discard it.

So, now there's no Edge Remained, So the Step 4 was the Final Formation of MST because after there no MST has been developed. due to formation of loop/cycle.

Note: Only Calculate the Edges which are pre-resulted as "Not Creating Loop/Cycle" while formation. Because this kind of Edges are only Eligible for Final Calculation. Edges which create Loop/Cycle are not Eligible and Hence Trashed.

See, In the Final Calculation - We have taken Step 1, Step 2, Step 3 and Step 4; because this steps are not creating any Loop or Cycle. So, the Edges from this Steps are Granted for Calculation. And Step 5, Step 6 and Step 7 are creating a Loop/Cycle so they will not be considered in Final Calculations.

So, the Final MST (Minimum Spanning Tree) resulted from the given weighted graph is solved by using Kruskal's Algorithm.

The Final Layout of MST is given below -

Moving towards the calculation,

the cost of the MST is = AB + DE + BC + CD = 1 + 2 + 3 + 4 = 10

So, the Algorithm Needs to Stop Here as the Result is Out.

Data Structure Learning is a Necessity - Harshal Suryawanshi

Introduction to Python Programming

2022-03-26T09:54:00.004+05:30

Programming is a way of giving input or telling our computer to perform tasks so that computer takes our command and search for it and then return the result.

Everything you provide to computer is converted in to machine code. For example text, audio, video, images, etc..

We are here to learn about one of the programming language i.e. Python.

Python is a programming language invented by Guido Van Rossum. In 1989 he started implementing concept of ABC language(it was also a language but have much more issues with it). He wanted to make most easier and less coding language.

In February 1991, he released first version of Python with version name 0.9.0. In this version the features of this programming language were exception handling, functions, and the core data types like list, set, dict, tuple etc..

Python was named on "Monty Python's Flying Circus". Guido was one the biggest fan of this circus so he decided to name Python.

Finally he released his second version with tons of features like lambdas, mapping, reduce and filter, etc.. in January 1994 and named it "Python 1.0".

He release Python's most successful version of that time i.e. "Python 2.0" in October 2000,which had features like list comprehensions, garbage collector, and Unicode support, etc..

Finally in December 2008 Guido released "Python 3.0" version or "Python 3000" or "py3k",with new features like:

Print is a function now.
View and iterators instead of lists.
The rules for ordering comparisons have been simplified.
There should be only one integer data type i.e. int, long is also added in int.
Division of two numbers will return a float value instead of an integer.
Text vs Data instead of Unicode vs 8-bit, and some new syntaxes.

Let me show you the first program of Python to you:-

print("Hello World!")

and that's it you are done will discuss in another blog on how this work till then you understand the basic of Python.

Features of Python Programming language:-

1. Python is interpreted programming language.

2. It has very simple syntaxes and have extensive library.

3. Readability is very good in Python.

4. Less number of instructions.

5. Easy to execute as well as easy to write programs in Python.

6. Less error prone programming language.

7. Python is static as well as dynamic programming language.

8. Pre-processor is not required in Python.

9. Python is a platform Independent.

10. Python is both procedure oriented as well as object oriented programming language.

Let's talk about some Language Fundamental things:

To create Python applications we need some constructs by default from Python programming language called as Language Fundamental.

We have total 4 language fundamentals:

1. Tokens

2. Data Types

3. Type Casting

4. Python Statements

Let's look out all of them in brief:

1. Tokens:- The collection of lexemes in a particular group is called Tokens and the logical unit in programming is called Lexeme.

Example:-

 sum = number1 + number2

   Lexemes: sum, =, number1, +, number2


   Identifiers: sum, number1, number2

 Operators: =, +

Tokens have 4 types, let's see them with description:-

1. Identifiers:

Giving name to the programming elements or variables, functions, classes, etc.. called as Identifiers.

There are some rules to write them:-

> Identifier should not be start from number.

example:-

21roll_number ---> Incorrect

> It must start from letter or underscore(_) symbol.

example:-

roll_number = 21 -->correct
_rollnumber = 21 -->correct

> Leaving underscore we cannot use any other symbols like +, -, *, %, etc..

example:-

my_age = 21 -->correct
my+age = 21 -->Incorrect

>Identifiers should not allow white spaces in between them

example:-

my name = "CodeWithDevops" -->Incorrect

> Identifiers are case sensitive means capital letters and small letters will create 2 different Identifiers.

example:-

name = "ABC"
Name = "ABC" -->Both are correct but both are different

You cannot create identifier with keywords.

example:-

if = "Hi" -->Incorrect

Note:- Variable and Identifiers are not same, variable is a memory location where data is stored, and name of the variable is called as Identifier.

2. Literals:

Literal is a constant assigned to the variable.

example:-

number1 = 10
age = 21
name = "CodeWithDevops"

Literals are also having 2 types:

1. Numeric Literals:

As you can think from name that numeric means related to numbers. This literal stored int and float values.

example:-

roll_number = 11
pi = 3.142

2. Non Numeric Literals

Non Numeric Literal stores boolean and string values.

example:-

are_you_student = True
name = "CodeWithDevops"

3. Keywords/ Reserved Words

If any predefined word has both word recognition as well as internal functonality then they are called as Keywords/Reserved Words.

these words are:


  'False', 'None', 'True', '__peg_parser__', 'and', 'as', 'assert', 'async',
  'await', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except',
  'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda',
  'nonlocal', 'not', 'or', 'pass', 'raise', 'return', 'try', 'while', 'with',
  'yield'

4. Operators:

Operator is a symbol, that perform a particular operation over the provided operands.

There are many types of operators, but will explain next time but for basic knowledge let me show you a few of them:

1. Arithmetic Operator:-

It will perform arithmetic functions like adding, subtracting, multiplying, dividing, etc..

2. Assignment Operator:-

This operator is use to assign values the identifiers.

So this is it for your basic knowledge, will continue in next blog till then take care.

Coding a Pie Chart using Python

2022-03-22T20:29:00.000+05:30

Pie Chart is a Circular Graphic Formation, which is customizable and divided into slices to illustrate the numerical proportion. The Proportion can be in Percentage or Ratio.

This Pie Chart can help user to get proper ration of their task and work accordingly. Further (which is not discussed here), you can implement GUI in it and create a apk file. Simply, Convert your .py file to .apk easily.

Why Use Pie Chart?

Answer - Pie Charts can be used to show percentages graphically in the form of slices.

Today, We'll Demonstrate a Pie Chart which is build in Python Programming.

Python is a truly wonderful language. When somebody comes up with a good idea it takes about 1 minute and five lines to program something that almost does what you want. Then it takes only an hour to extend the script to 300 lines, after which it still does almost what you want. - Jack Jansen

Here I'll Provide Source Code for your Understanding -

So, Let's Get Started with Building a Pie Chart in Python.

For this Python Program, you'll need to import matplotlib.pyplot as plt.

Source Code - (Pie Chart)

import matplotlib.pyplot as plt
x=[30, 30, 20, 20]
la=["Satyaprakash","Aakash","Kamlesh", "Deepti"]
plt.pie(x,labels=la)
plt.show()

Output for the Following Code is Displayed Below.

How to Calculate a Pie Chart Mathematically?

Answer: To Calculate, Multiply the Percentage (%) of Slice by the Total Numbers of Data given and Divide it with 100.

This Portion or Line of the Code Represents Quantity or Numerical Percentage of Data-Set.

x=[30, 30, 20, 20]

And the Code, represent the Data-Sets in Pie Chart.

  la=["Satyaprakash","Aakash","Kamlesh", "Deepti"]

So, this was the Program for coding a Pie Chart in Python.

I will recommend you try this program on your own. You Can Copy/Paste the Code from Above.

Installation and Usage of OpenCV Library in Python Programming

2022-03-20T06:30:00.000+05:30

In this Article, We'll Discuss about the most important library named as "OpenCV" in Python Programming. So, in out last article's about NumPy, Matplotlib, Pandas - ahead I thought to write more on libraries in Python Programming.

OpenCV is a Python open-source library, which is used for computer vision in Artificial intelligence, Machine Learning, face recognition, etc.

OpenCV is a library of Python Programming functions mainly aimed at real-time computer vision. OpenCV is originally developed by Intel and later on supported by Willow Garage then Itseez.

This Library is Cross-Platform and free to use under the open source Apache 2 License.

OpenCV was released in June 2000.

How to Install OpenCV?

pip install opencv-python

Installation and Usage

If you have previous/other manually installed (= not installed via pip) version of OpenCV installed (e.g. cv2 module in the root of Python's site-packages), remove it before installation to avoid conflicts.

Make sure that your pip version is up-to-date (19.3 is the minimum supported version): pip install --upgrade pip. Check version with pip -V. For example Linux distributions ship usually with very old pip versions which cause a lot of unexpected problems especially with the many Linux format.

Select the correct package for your environment:

There are four different packages (see options 1, 2, 3 and 4 below) and you should SELECT ONLY ONE OF THEM. Do not install multiple different packages in the same environment. There is no plugin architecture: all the packages use the same namespace (cv2). If you installed multiple different packages in the same environment, uninstall them all with pip uninstall and reinstall only one package.

a. Packages for standard desktop environments (Windows, macOS, almost any GNU/Linux distribution)

Option 1 - Main modules package: pip install opencv-python

Option 2 - Full package (contains both main modules and contrib/extra modules): pip install opencv-contrib-python (check contrib/extra modules listing from OpenCV documentation)

b. Packages for server (headless) environments (such as Docker, cloud environments etc.), no GUI library dependencies

These packages are smaller than the two other packages above because they do not contain any GUI functionality (not compiled with Qt / other GUI components). This means that the packages avoid a heavy dependency chain to X11 libraries and you will have for example smaller Docker images as a result. You should always use these packages if you do not use cv2.imshow et al. or you are using some other package (such as PyQt) than OpenCV to create your GUI.

Option 3 - Headless main modules package: pip install opencv-python-headless

Option 4 - Headless full package (contains both main modules and contrib/extra modules): pip install opencv-contrib-python-headless (check contrib/extra modules listing from OpenCV documentation)

Import the package:

import cv2

All packages contain Haar cascade files. cv2.data.haarcascades can be used as a shortcut to the data folder. For example:


      cv2.CascadeClassifier(cv2.data.haarcascades +
      "haarcascade_frontalface_default.xml")

OpenCV is the huge open-source library for the computer vision, machine learning, and image processing and now it plays a major role in real-time operation which is very important in today’s systems. By using it, one can process images and videos to identify objects, faces, or even handwriting of a human. When it integrated with various libraries, such as NumPy, python is capable of processing the OpenCV array structure for analysis. To Identify image pattern and its various features we use vector space and perform mathematical operations on these features.

The first OpenCV version was 1.0. OpenCV is released under a BSD license and hence it’s free for both academic and commercial use. It has C++, C, Python and Java interfaces and supports Windows, Linux, Mac OS, iOS and Android. When OpenCV was designed the main focus was real-time applications for computational efficiency. All things are written in optimized C/C++ to take advantage of multi-core processing.

Example of Linked List in Data Structure

2022-03-19T09:30:00.000+05:30

Hello everyone, Today we are learning about Linked List.

Linked List is an very useful algorithm that is used at the place of array when there is large amount of data to arrange or operate a large amount of data.

A linked list is a linear data structure where each element is a separate object.

Linked list elements are not stored at contiguous location; the elements are linked using pointers.

Each node of a list is made up of two items - the data and a reference to the next node. The last node has a reference to null. The entry point into a linked list is called the head of the list. It should be noted that head is not a separate node, but the reference to the first node. If the list is empty then the head is a null reference.

We can insert elements from beginning and end in a Linked List also same for deletions purposes.

Below there is an example of linked list with integer data:-

class Node:
    def __init__(self, value):
        self.val = value  # Assign value

        self.next = None  # Initialize next as null

class LinkedList:
    def __init__(self): # initializes linked list
        self.head = None

Above was the example to just give you an understanding about linked list.

Now lets see an example for all the operations:-

class Node:
    def __init__(self, data=None, next=None):
        self.data = data
        self.next = next

class LinkedList:
    def __init__(self):
        self.head = None

    def print(self):
        if self.head is None:
            print("Linked list is empty")
            return

        itr = self.head
        llstr = ''
        while itr:
              llstr += str(itr.data)+' --> ' if itr.next else str(itr.data)
 
            itr = itr.next
        print(llstr)

    def get_length(self):
        count = 0
        itr = self.head

        while itr:
            count += 1
            itr = itr.next
        return count

    def insert_at_begining(self, data):
        node = Node(data, self.head)
        self.head = node

    def insert_at_end(self, data):
        if self.head is None:
            self.head = Node(data, None)
            return

        itr = self.head
        while itr.next:
            itr = itr.next
        itr.next = Node(data, None)

    def insert_at(self, index, data):
          if index < 0 or index > self.get_length():
              raise Exception("Invalid Index")

        if index == 0:
            self.insert_at_begining(data)
            return
        count = 0
        itr = self.head
        while itr:
            if count == index - 1:

                  node = Node(data,itr.next)
                itr.next = node
                break
            itr = itr.next
            count += 1

    def remove_at(self, index):
          if index < 0 or index >= self.get_length():
              raise Exception("Invalid Index")

        if index == 0:
            self.head = self.head.next
            return
        count = 0
        itr = self.head
        while itr:
            if count == index - 1:
                  itr.next = itr.next.next
  
                break
            itr = itr.next
            count += 1

    def insert_values(self, data_list):
        self.head = None

        for data in data_list:
            self.insert_at_end(data)

if __name__ == '__main__':

    ll = LinkedList()

    ll.insert_values(["banana", "mango", "grapes", "orange"])
    ll.insert_at(1, "blueberry")
    ll.remove_at(2)
    ll.print()

    ll.insert_values([45, 7, 12, 567, 99])
    ll.insert_at_end(67)
    ll.print()

Output:-

banana --> blueberry --> grapes --> orange
45 --> 7 --> 12 --> 567 --> 99 --> 67

A Complete Tutorial in Python to Design a “Pikachu” using Turtle

2022-03-18T09:30:00.001+05:30

In Today's Article, I'll Demonstrate you How to Design a Pikachu using Turtle in Python.

Step 1: Open any Editor (Eg. VS Code)

Step 2: Copy and Paste the Code Provided Below.

Note: Make Sure that you Have Installed Turtle Module on your System.

To Install: Type the Following Command in Command Prompt.

pip install PythonTurtle

Step 3: Source Code.

import turtle
class Pikachu:
 
    def __init__(self):
        self.t = turtle.Turtle()
        t = self.t
        t.pensize(3)
        t.speed(9)
 
    def move_pointer(self, x, y):
        self.t.penup()
        self.t.goto(x, y)
        self.t.pendown()
 
    def eye1(self, x, y):
        self.move_pointer(x, y)
        t = self.t
        t.seth(0)
        t.fillcolor('#333333')
        t.begin_fill()
        t.circle(22)
        t.end_fill()
 
        self.move_pointer(x, y + 10)
        t.fillcolor('#000000')
        t.begin_fill()
        t.circle(10)
        t.end_fill()
 
        self.move_pointer(x + 6, y + 22)
        t.fillcolor('#ffffff')
        t.begin_fill()
        t.circle(10)
        t.end_fill()
 
    def eye2(self, x, y):
        self.move_pointer(x, y)
        t = self.t
        t.seth(0)
        t.fillcolor('#333333')
        t.begin_fill()
        t.circle(22)
        t.end_fill()
 
        self.move_pointer(x, y + 10)
        t.fillcolor('#000000')
        t.begin_fill()
        t.circle(10)
        t.end_fill()
 
        self.move_pointer(x - 6, y + 22)
        t.fillcolor('#ffffff')
        t.begin_fill()
        t.circle(10)
        t.end_fill()
 
    def mouth(self, x, y):
        self.move_pointer(x, y)
        t = self.t
 
        t.fillcolor('#88141D')
        t.begin_fill()
        #
        l1 = []
        l2 = []
        t.seth(190)
        a = 0.7
        for i in range(28):
            a += 0.1
            t.right(3)
            t.fd(a)
            l1.append(t.position())
 
        self.move_pointer(x, y)
 
        t.seth(10)
        a = 0.7
        for i in range(28):
            a += 0.1
            t.left(3)
            t.fd(a)
            l2.append(t.position())
 
        t.seth(10)
        t.circle(50, 15)
        t.left(180)
        t.circle(-50, 15)
 
        t.circle(-50, 40)
        t.seth(233)
        t.circle(-50, 55)
        t.left(180)
        t.circle(50, 12.1)
        t.end_fill()
        self.move_pointer(17, 54)
        t.fillcolor('#DD716F')
        t.begin_fill()
        t.seth(145)
        t.circle(40, 86)
        t.penup()
        for pos in reversed(l1[:20]):
            t.goto(pos[0], pos[1] + 1.5)
        for pos in l2[:20]:
            t.goto(pos[0], pos[1] + 1.5)
        t.pendown()
        t.end_fill()
        self.move_pointer(-17, 94)
        t.seth(8)
        t.fd(4)
        t.back(8)
 
    #
    def cheek1(self, x, y):
        turtle.tracer(False)
        t = self.t
        self.move_pointer(x, y)
        t.seth(300)
        t.fillcolor('#DD4D28')
        t.begin_fill()
        a = 2.3
        for i in range(120):
            if 0 <= i < 30 or 60 <= i < 90:
                a -= 0.05
                t.lt(3)
                t.fd(a)
            else:
                a += 0.05
                t.lt(3)
                t.fd(a)
        t.end_fill()
        turtle.tracer(True)
 
    def cheek2(self, x, y):
        t = self.t
        turtle.tracer(False)
        self.move_pointer(x, y)
        t.seth(60)
        t.fillcolor('#DD4D28')
        t.begin_fill()
        a = 2.3
        for i in range(120):
            if 0 <= i < 30 or 60 <= i < 90:
                a -= 0.05
                t.lt(3)
                t.fd(a)
            else:
                a += 0.05
                t.lt(3)
                t.fd(a)
        t.end_fill()
        turtle.tracer(True)
 
    def ear1(self, x, y):
        t = self.t
        self.move_pointer(x, y)
        t.fillcolor('#000000')
        t.begin_fill()
        t.seth(330)
        t.circle(100, 35)
        t.seth(219)
        t.circle(-300, 19)
        t.seth(110)
        t.circle(-30, 50)
        t.circle(-300, 10)
        t.end_fill()
 
    def ear2(self, x, y):
        t = self.t
        self.move_pointer(x, y)
        t.fillcolor('#000000')
        t.begin_fill()
        t.seth(300)
        t.circle(-100, 30)
        t.seth(35)
        t.circle(300, 15)
        t.circle(30, 50)
        t.seth(190)
        t.circle(300, 17)
        t.end_fill()
 
    def draw(self):
        t = self.t
 
        t.fillcolor('#F6D02F')
        t.begin_fill()
        #
        t.penup()
        t.circle(130, 40)
        t.pendown()
        t.circle(100, 105)
        t.left(180)
        t.circle(-100, 5)
        t.seth(20)
        t.circle(300, 30)
        t.circle(30, 50)
        t.seth(190)
        t.circle(300, 36)
        t.seth(150)
        t.circle(150, 70)
        t.seth(200)
        t.circle(300, 40)
        t.circle(30, 50)
        t.seth(20)
        t.circle(300, 35)
        t.seth(240)
        t.circle(105, 95)
        t.left(180)
        t.circle(-105, 5)
        t.seth(210)
        t.circle(500, 18)
        t.seth(200)
        t.fd(10)
        t.seth(280)
        t.fd(7)
        t.seth(210)
        t.fd(10)
        t.seth(300)
        t.circle(10, 80)
        t.seth(220)
        t.fd(10)
        t.seth(300)
        t.circle(10, 80)
        t.seth(240)
        t.fd(12)
        t.seth(0)
        t.fd(13)
        t.seth(240)
        t.circle(10, 70)
        t.seth(10)
        t.circle(10, 70)
        t.seth(10)
        t.circle(300, 18)
 
        t.seth(75)
        t.circle(500, 8)
        t.left(180)
        t.circle(-500, 15)
        t.seth(250)
        t.circle(100, 65)
        t.seth(320)
        t.circle(100, 5)
        t.left(180)
        t.circle(-100, 5)
        t.seth(220)
        t.circle(200, 20)
        t.circle(20, 70)
 
        t.seth(60)
        t.circle(-100, 20)
        t.left(180)
        t.circle(100, 20)
        t.seth(300)
        t.circle(10, 70)
 
        t.seth(60)
        t.circle(-100, 20)
        t.left(180)
        t.circle(100, 20)
        t.seth(10)
        t.circle(100, 60)
        t.seth(180)
        t.circle(-100, 10)
        t.left(180)
        t.circle(100, 10)
        t.seth(5)
        t.circle(100, 10)
        t.circle(-100, 40)
        t.circle(100, 35)
        t.left(180)
        t.circle(-100, 10)
        t.seth(290)
        t.circle(100, 55)
        t.circle(10, 50)
 
        t.seth(120)
        t.circle(100, 20)
        t.left(180)
        t.circle(-100, 20)
 
        t.seth(0)
        t.circle(10, 50)
 
        t.seth(110)
        t.circle(100, 20)
        t.left(180)
        t.circle(-100, 20)
 
        t.seth(30)
        t.circle(20, 50)
 
        t.seth(100)
        t.circle(100, 40)
        t.seth(200)
        t.circle(-100, 5)
        t.left(180)
        t.circle(100, 5)
        t.left(30)
        t.circle(100, 75)
        t.right(15)
        t.circle(-300, 21)
        t.left(180)
        t.circle(300, 3)
        t.seth(43)
        t.circle(200, 60)
 
        t.right(10)
        t.fd(10)
 
        t.circle(5, 160)
        t.seth(90)
        t.circle(5, 160)
        t.seth(90)
 
        t.fd(10)
        t.seth(90)
        t.circle(5, 180)
        t.fd(10)
 
        t.left(180)
        t.left(20)
        t.fd(10)
        t.circle(5, 170)
        t.fd(10)
        t.seth(240)
        t.circle(50, 30)
 
        t.end_fill()
        self.move_pointer(130, 125)
        t.seth(-20)
        t.fd(5)
        t.circle(-5, 160)
        t.fd(5)
        self.move_pointer(166, 130)
        t.seth(-90)
        t.fd(3)
        t.circle(-4, 180)
        t.fd(3)
        t.seth(-90)
        t.fd(3)
        t.circle(-4, 180)
        t.fd(3)
        self.move_pointer(168, 134)
        t.fillcolor('#F6D02F')
        t.begin_fill()
        t.seth(40)
        t.fd(200)
        t.seth(-80)
        t.fd(150)
        t.seth(210)
        t.fd(150)
        t.left(90)
        t.fd(100)
        t.right(95)
        t.fd(100)
        t.left(110)
        t.fd(70)
        t.right(110)
        t.fd(80)
        t.left(110)
        t.fd(30)
        t.right(110)
        t.fd(32)
 
        t.right(106)
        t.circle(100, 25)
        t.right(15)
        t.circle(-300, 2)
        ##############
        t.seth(30)
        t.fd(40)
        t.left(100)
        t.fd(70)
        t.right(100)
        t.fd(80)
        t.left(100)
        t.fd(46)
        t.seth(66)
        t.circle(200, 38)
        t.right(10)
        t.fd(10)
        t.end_fill()
        t.fillcolor('#923E24')
        self.move_pointer(126.82, -156.84)
        t.begin_fill()
 
        t.seth(30)
        t.fd(40)
        t.left(100)
        t.fd(40)
        t.pencolor('#923e24')
        t.seth(-30)
        t.fd(30)
        t.left(140)
        t.fd(20)
        t.right(150)
        t.fd(20)
        t.left(150)
        t.fd(20)
        t.right(150)
        t.fd(20)
        t.left(130)
        t.fd(18)
        t.pencolor('#000000')
        t.seth(-45)
        t.fd(67)
        t.right(110)
        t.fd(80)
        t.left(110)
        t.fd(30)
        t.right(110)
        t.fd(32)
        t.right(106)
        t.circle(100, 25)
        t.right(15)
        t.circle(-300, 2)
        t.end_fill()
 
        self.cap(-134.07, 147.81)
        self.mouth(-5, 25)
        self.cheek1(-126, 32)
        self.cheek2(107, 63)
        self.ear1(-250, 100)
        self.ear2(140, 270)
        self.eye1(-85, 90)
        self.eye2(50, 110)
        t.hideturtle()
 
    def cap(self, x, y):
        self.move_pointer(x, y)
        t = self.t
        t.fillcolor('#CD0000')
        t.begin_fill()
        t.seth(200)
        t.circle(400, 7)
        t.left(180)
        t.circle(-400, 30)
        t.circle(30, 60)
        t.fd(50)
        t.circle(30, 45)
        t.fd(60)
        t.left(5)
        t.circle(30, 70)
        t.right(20)
        t.circle(200, 70)
        t.circle(30, 60)
        t.fd(70)
        t.right(35)
        t.fd(50)
        t.circle(8, 100)
        t.end_fill()
        self.move_pointer(-168.47, 185.52)
        t.seth(36)
        t.circle(-270, 54)
        t.left(180)
        t.circle(270, 27)
        t.circle(-80, 98)
 
        t.fillcolor('#444444')
        t.begin_fill()
        t.left(180)
        t.circle(80, 197)
        t.left(58)
        t.circle(200, 45)
        t.end_fill()
 
        self.move_pointer(-58, 270)
        t.pencolor('#228B22')
        t.dot(35)
 
        self.move_pointer(-30, 280)
        t.fillcolor('#228B22')
        t.begin_fill()
        t.seth(100)
        t.circle(30, 180)
        t.seth(190)
        t.fd(15)
        t.seth(100)
        t.circle(-45, 180)
        t.right(90)
        t.fd(15)
        t.end_fill()
        t.pencolor('#000000')
 
    def start(self):
        self.draw()
 
 
def main():
    print('Painting the Pikachu... ')
    turtle.screensize(800, 600)
    turtle.title('Pikachu')
    cartoon = Pikachu()
    cartoon.start()
    turtle.mainloop()
 
 
if __name__ == '__main__':
    main()

Step 4: Now, Save the Code and Run it. Here's the Final Preview After all the Creating Animations.

Step 5: You're Done !

We Have Created a Pikachu using Turtle Module in Python. Here's a Video; How the Code Works after Compiling. It's a Animation of Designing a Pikachu.

Binary Search Program in Java

2022-03-17T09:30:00.000+05:30

Binary Search is an algorithm which is used to find something from arrays or list. We use this method instead of linear search for faster results.

Binary search is the search technique which works efficiently on the sorted lists. Hence, in order to search an element into some list by using binary search technique, we must ensure that the list is sorted.

Binary search follows divide and conquer approach in which, the list is divided into two halves and the item is compared with the middle element of the list. If the match is found then, the location of middle element is returned otherwise, we search into either of the halves depending upon the result produced through the match.

Source Code:

class BinarySearch {

      boolean binarySearchAlgo(int [] arr, int start, int end, int target){
 
          int midIndex = ((start + end)/2);

          if (start > end) return false;
  
          if (arr[midIndex] == target) return true;
  
          if (arr[midIndex] > target) return binarySearchAlgo(arr, start, midIndex-1, target);
  
          else
  
              return binarySearchAlgo(arr, midIndex+1, end, target);
  

  }


      public static void main(String[] args) {

          int[] arr = {2,4,6,7,9,11,34,45,73,91};

          int start = 0;
  
          int end = arr.length-1;
  
          int target = 73;
  
          BinarySearch obj = new BinarySearch();
 
          System.out.println(obj.binarySearchAlgo(arr, start, end, target));
    }
  }

Output:

 true

Reverse a String of User Input in Java Programming

2022-03-16T09:30:00.002+05:30

String is a sequence of characters that is considered to be an object in Java. In Java, there are various operations that you can perform on the String object. One of the most widely used operations on a string object is String Reverse.

Java program to reverse a string that a user inputs. In this Program, the User Input will be totally reversed as typed. For Example: See the Source Code and Output.

Source Code:

import java.util.*; 
class ReverseString 
{

      public static void main(String args[])

  {

        String original, reverse = "";
 
        Scanner in = new Scanner(System.in);
        System.out.println("Enter a string to reverse");

    original = in.nextLine();

        int length = original.length();
        for (int i = length - 1 ; i >= 0 ; i--)
  
        reverse = reverse + original.charAt(i);
        System.out.println("Reverse of the string: " + reverse);  
  }
 }

Turtle in Python

2022-03-16T09:30:00.000+05:30

Turtle graphics is a popular way for introducing programming to kids. It was part of the original Logo programming language developed by Wally Feurzeig, Seymour Papert and Cynthia Solomon in 1967.

The turtle module is an extended reimplementation of the same-named module from the Python standard distribution up to version Python 2.5.

The turtle module provides turtle graphics primitives, in both object-oriented and procedure-oriented ways. Because it uses tkinter for the underlying graphics, it needs a version of Python installed with Tk support.

The object-oriented interface uses essentially two+two classes:

The TurtleScreen class defines graphics windows as a playground for the drawing turtles. Its constructor needs a tkinter.Canvas or a ScrolledCanvas as argument. It should be used when turtle is used as part of some application.
The function Screen() returns a singleton object of a TurtleScreen subclass. This function should be used when turtle is used as a standalone tool for doing graphics. As a singleton object, inheriting from its class is not possible.

All methods of TurtleScreen/Screen also exist as functions, i.e. as part of the procedure-oriented interface.

RawTurtle (alias: RawPen) defines Turtle objects which draw on a TurtleScreen. Its constructor needs a Canvas, ScrolledCanvas or TurtleScreen as argument, so the RawTurtle objects know where to draw.

Derived from RawTurtle is the subclass Turtle (alias: Pen), which draws on “the” Screen instance which is automatically created, if not already present.

First to install turtle in your machine write a command given below:-

pip install turtle

After installation always remember that first you have to import turtle then you can use it.

Eg:-

import turtle
turtle.circle(150, 360)  # draw a circle
turtle.position()
(0.00,200.00)
turtle.heading()
180.0

Eg:-

from turtle import *
color('red', 'yellow')
begin_fill()
while True:
    forward(200)
    left(170)
    if abs(pos()) < 1:
        break
end_fill()
done()

A Complete Tutorial in Python to Design an Indian Flag using Turtle

2022-03-15T09:30:00.001+05:30

As an Indian, it's becomes a very proud moment to create and design our Indian Flag at a level in Programming. In this Tutorial, I'll Provide and Explain that How to Make or Illustrate an Indian Flag in Python Programming using Turtle.

Little about Turtle: It's a Module which Provides Graphics Primitives in Python.

Step 1: Open any Editor (Eg. VS Code)

Step 2: Copy and Paste the Code Provided Below.

Note: Make Sure that you Have Installed Turtle Module on your System.

To Install: Type the Following Command in Command Prompt.

pip install PythonTurtle

Step 3: Source Code.

import turtle
from turtle import *
  
# screen for output

screen = turtle.Screen()
screen.title("Indian Flag by GeekInsider (geekinsider.in)")

# Defining a turtle Instance  
t = turtle.Turtle()
 speed(0)
  # initially penup()
 t.penup()
t.goto(-400, 250)
t.pendown()
 # Orange Rectangle

# white rectangle
 t.color("orange")
 t.begin_fill()
  t.forward(800)
  t.right(90)
 t.forward(167)
 t.right(90)
 t.forward(800)
  t.end_fill()
  t.color("white")
 t.left(90)
  t.forward(167)

# Green Rectangle
  t.color("green") 
t.begin_fill() 
t.forward(167)
t.left(90) 
t.forward(800) 
t.left(90) 
t.forward(167) 
t.end_fill()

# Big Blue Circle

t.penup()
t.goto(70, 0)
t.pendown()
t.color("navy")
t.begin_fill()
t.circle(70)
t.end_fill()

# Big White Circle

t.penup()
t.goto(60, 0)
t.pendown() 
t.color("white") 
t.begin_fill()
t.circle(60) 
t.end_fill()

# Mini Blue Circles

t.penup()
t.goto(-57, -8)
t.pendown()
t.color("navy")
for i in range(24):
    t.begin_fill()
    t.circle(3)
    t.end_fill()
    t.penup()
    t.forward(15)
    t.right(15)
    t.pendown()

# Small Blue Circle
 
t.penup()
t.goto(20, 0)
t.pendown()
t.begin_fill()
t.circle(20)
t.end_fill()
  # Spokes

t.penup()
t.goto(0, 0)
t.pendown()
t.pensize(2)
for i in range(24):
    t.forward(60)
    t.backward(60)
    t.left(15)
 
# to hold the

# output window

turtle.done()

Step 4: Now, Save the Code and Run it. Here's the Final Preview After all the Creating Animations.

Step 5: You're Done !

We Have Created an Indian Flag using Turtle Module in Python. Here's a Video; How the Code Works after Compiling. It's a Animation of Designing an Indian Flag.

Note: This Video is Fast-Forwarded Video: Just for an Idea How an Indian Flag will Get it's Preview.

To Fast Forward or to Speed-Up the Process in the Flag Design into Source Code, you can change the following values inside it as demonstrated below.

Into the Source Code: Find # Defining a Turtle Instance and Change the Values as per your need.

Top 10 Python Libraries for Data Science

2022-03-14T09:30:00.000+05:30

Python has been a charmer for data scientists for a while now. The more I interact with resources, literature, courses, training, and people in Data Science, proficient knowledge of Python emerges as a good asset to have. Having said that, when I started flourishing my Python skills, I had a list of Python libraries I had to know about. A few moments later…

Python has been a charmer for data scientists for a while now.😀

People in Data Science definitely know about the Python libraries that can be used in Data Science but when asked in an interview to name them or state its function, we often fumble up or probably not remember more than 5 libraries.

Here today, I have curated a list of 10 Python libraries that helps in Data Science and its periphery, when to use them, what are its significant features and the advantages.

In this story, I have briefly outlined 10 most useful Python libraries for data scientists and engineers, based on my recent experience and explorations. Read the full story to know about 4 bonus libraries!

1. Pandas

Pandas is an open-source Python package that provides high-performance, easy-to-use data structures and data analysis tools for the labeled data in Python programming language. Pandas stand for Python Data Analysis Library. Who ever knew that?

When to use? Pandas is a perfect tool for data wrangling or munging. It is designed for quick and easy data manipulation, reading, aggregation, and visualization.

Pandas take data in a CSV or TSV file or a SQL database and create a Python object with rows and columns called a data frame. The data frame is very similar to a table in statistical software, say Excel or SPSS.

What can you do with Pandas?

Indexing, manipulating, renaming, sorting, merging data frame
Update, Add, Delete columns from a data frame
Impute missing files, handle missing data or NANs
Plot data with histogram or box plot

This makes Pandas a foundation library in learning Python for Data Science.

2. NumPy

One of the most fundamental packages in Python, NumPy is a general-purpose array-processing package. It provides high-performance multidimensional array objects and tools to work with the arrays. NumPy is an efficient container of generic multi-dimensional data.

NumPy’s main object is the homogeneous multidimensional array. It is a table of elements or numbers of the same datatype, indexed by a tuple of positive integers. In NumPy, dimensions are called axes and the number of axes is called rank. NumPy’s array class is called ndarray aka array.

When to use? NumPy is used to process arrays that store values of the same datatype. NumPy facilitates math operations on arrays and their vectorization. This significantly enhances performance and speeds up the execution time correspondingly.

What can you do with NumPy?

Basic array operations: add, multiply, slice, flatten, reshape, index arrays
Advanced array operations: stack arrays, split into sections, broadcast arrays
Work with DateTime or Linear Algebra
Basic Slicing and Advanced Indexing in NumPy Python

3. SciPy

The SciPy library is one of the core packages that make up the SciPy stack. Now, there is a difference between SciPy Stack and SciPy, the library. SciPy builds on the NumPy array object and is part of the stack which includes tools like Matplotlib, Pandas, and SymPy with additional tools,

SciPy library contains modules for efficient mathematical routines as linear algebra, interpolation, optimization, integration, and statistics. The main functionality of the SciPy library is built upon NumPy and its arrays. SciPy makes significant use of NumPy.

When to use? SciPy uses arrays as its basic data structure. It has various modules to perform common scientific programming tasks as linear algebra, integration, calculus, ordinary differential equations, and signal processing.

4. Matplotlib

This is undoubtedly my favorite and a quintessential Python library. You can create stories with the data visualized with Matplotlib. Another library from the SciPy Stack, Matplotlib plots 2D figures.

When to use? Matplotlib is the plotting library for Python that provides an object-oriented API for embedding plots into applications. It is a close resemblance to MATLAB embedded in Python programming language.

What can you do with Matplotlib?

Histogram, bar plots, scatter plots, area plot to pie plot, Matplotlib can depict a wide range of visualizations. With a bit of effort and tint of visualization capabilities, with Matplotlib, you can create just any visualizations:

Line plots
Scatter plots
Area plots
Bar charts and Histograms
Pie charts
Stem plots
Contour plots
Quiver plots
Spectrograms

Matplotlib also facilitates labels, grids, legends, and some more formatting entities with Matplotlib. Basically, everything that can be drawn!

5. Seaborn

So when you read the official documentation on Seaborn, it is defined as the data visualization library based on Matplotlib that provides a high-level interface for drawing attractive and informative statistical graphics. Putting it simply, seaborn is an extension of Matplotlib with advanced features.

So, what is the difference between Matplotlib and Seaborn? Matplotlib is used for basic plotting; bars, pies, lines, scatter plots and stuff whereas, seaborn provides a variety of visualization patterns with less complex and fewer syntax.

What can you do with Seaborn?

Determine relationships between multiple variables (correlation)
Observe categorical variables for aggregate statistics
Analyze uni-variate or bi-variate distributions and compare them between different data subsets
Plot linear regression models for dependent variables
Provide high-level abstractions, multi-plot grids

Seaborn is a great second-hand for R visualization libraries like corrplot and ggplot.

6. Scikit Learn

Introduced to the world as a Google Summer of Code project, Scikit Learn is a robust machine learning library for Python. It features ML algorithms like SVMs, random forests, k-means clustering, spectral clustering, mean shift, cross-validation and more... Even NumPy, SciPy and related scientific operations are supported by Scikit Learn with Scikit Learn being a part of the SciPy Stack.

When to use? Scikit-learn provides a range of supervised and unsupervised learning algorithms via a consistent interface in Python. Supervised learning models like Naive Bayes to grouping unlabeled data such as KMeans, Scikit learn would be your go-to.

What can you do with Scikit Learn?

Classification: Spam detection, image recognition
Clustering: Drug response, Stock price
Regression: Customer segmentation, Grouping experiment outcomes
Dimensionality reduction: Visualization, Increased efficiency
Model selection: Improved accuracy via parameter tuning
Pre-processing: Preparing input data as a text for processing with machine learning algorithms.

Scikit Learn focuses on modeling data; not manipulating data. We have NumPy and Pandas for summarizing and manipulation.

7. TensorFlow

TensorFlow is an AI library that helps developers to create large-scale neural networks with many layers using data flow graphs. TensorFlow also facilitates the building of Deep Learning models, push the state-of-the-art in ML/AI and allow easy deploy of ML-powered applications.

One of the most developed websites amongst all libraries is of TensorFlow. Giants like Google, Coca-Cola, Airbnb, Twitter, Intel, DeepMind, everyone uses TensorFlow!

When to Use? TensorFlow is quite efficient when it comes to classification, perception, understanding, discovering, predicting, and creating data.

What to do with TensorFlow?

Voice/Sound Recognition — IoT, Automotive, Security, UX/UI, Telecom
Sentiment Analysis — Mostly for CRM or CX
Text-Based Apps — Threat Detection, Google Translate, Gmail smart reply
Face Recognition — Facebook’s Deep Face, Photo tagging, Smart Unlock
Time Series — Recommendation from Amazon, Google, and Netflix
Video Detection — Motion Detection, Real-Time Threat Detection in Gaming, Security, Airports

8. Keras

Keras is TensorFlow’s high-level API for building and training Deep Neural Network code. It is an open-source neural network library in Python. With Keras, statistical modeling, working with images and text is a lot easier with simplified coding for deep learning.

What is the difference between Keras and TensorFlow after all?

Keras is a neural network Python library while TensorFlow is an open-source library for various machine learning tasks. TensorFlow provides both high-level and low-level APIs while Keras provides only high-level APIs. Keras is built for Python which makes it way more user-friendly, modular and composable than TensorFlow.

What can you do with Keras?

Determine percentage accuracy
Compute loss function
Create custom function layers
Built-in data and image processing
Write functions with repeating code blocks: 20, 50, 100 layers deep

9. Statsmodels

When I first learned R, conducting statistical tests, and statistical data exploration seemed the easiest in R and avoided Python for statistical analysis until I explored Statsmodels or Python.

When to use? Statsmodels is the ultimate Python package that provides easy computations for descriptive statistics and estimation and inference for statistical models.

What to do with Statsmodels?

Linear Regression
Correlation
Ordinary Least Squares (OLS) for the economist in you!
Survival analysis
Generalized linear models and Bayesian model
Uni-variate & bi-variate analysis, Hypothesis Testing (basically, what R can do!)

10. Plotly

Plotly is a quintessential graph plotting library for Python. Users can import, copy, paste, or stream data that is to be analyzed and visualized. Plotly offers a sandboxed Python(Something where you can run a Python that is limited in what it can do) Now I’ve had a hard time understanding what sandboxing is but I know for a fact that Plotly makes it easy!?

When to use? You can use Plotly if you want to create and display figures, update figures, hover over text for details. Plotly also has an additional feature of sending data to cloud servers. That’s interesting!

What can you do with Plotly?

The Plotly graph library has a wide range of graphs that you can plot:

Basic Charts: Line, Pie, Scatter, Bubble, Dot, Gantt, Sunburst, Treemap, Sankey, Filled Area Charts
Statistical and Seaborn Styles: Error, Box, Histograms, Facet and Trellis Plots, Tree plots, Violin Plots, Trend Lines
Scientific charts: Contour, Ternary, Log, Quiver, Carpet, Radar, Heat maps Windrose and Polar Plots
Financial Charts
Maps
Subplots
Transforms
Jupyter Widgets Interaction

Told you, Plotly is the quintessential plots library. Think of visualization and plotly can do it!

Stack Data Structure with Python

2022-03-13T10:37:00.133+05:30

One of most used Data Structure in day to day life is Stack and Queue data structure. In this blog you will see Stack data structure.

So, let's try to simplify stack for you...

Let's understand stack with an example, Suppose you are in kitchen and you took a plate and kept it on kitchen now you took another plate and kept over first plate. You didn't stop here you kept 25 plates on that plate. If I say you to take out 14th plate so what will you do?

You start removing plates from upper side right so you remove one plate from top and then another and you do it until you wouldn't get 14th plate.

So, Stack is a user-defined data structure in which last element will come first while removing element and first element in last. This is also called as First In Last Out algorithm.

We can solve stack problems in 2 ways, first one is list method and second one is using collections.

Let's check this by one program of notebooks so you can better understand about list method:-

# Creating an empty stack
stack = []

  # Inserting value inside the stack
stack.append("Notebook 1")
stack.append("Notebook 2")
stack.append("Notebook 3")
stack.append("Notebook 4")
stack.append("Notebook 5")
stack.append("Notebook 6")

# Print the stack
print(stack)

  # Let's remove the values from stack

  print("Removing: ",stack.pop())
  print("Removing: ",stack.pop())
  print("Removing: ",stack.pop())
print(stack)

Here you can understand every process as comment is inserted but let's see what is append and pop method?

In stack you will mostly work on push and pop methods, push method is use to insert value to the top and pop method is use to delete the value from the top.

here we are using list instead of arrays so list has it's own insertion method i.e. append, it insert values inside the list. and pop remove the element from the end side.

Output will be:

  ['Notebook 1', 'Notebook 2', 'Notebook 3', 'Notebook 4', 'Notebook 5',
    'Notebook 6']
Removing:  Notebook 6
Removing:  Notebook 5
Removing:  Notebook 4

  ['Notebook 1', 'Notebook 2', 'Notebook 3']

Hope it help you to understand stack Data Structure let's see a way more easy and lengthy example but for this example you have prior knowledge of Python's Functions..

stack = []
def push_element():
   while True:
   print("select the option to take
    input:")
   print("1.Int 2.Float 3.String
    4.Bool 0.quit")

   user_choice = int(input("Enter
    choice to push the element: "))

   if user_choice == 1:

   int_element = int(input("Enter the
    element: "))

   stack.append(int_element)

   print(stack)

   elif user_choice == 2:

   float_element = float(input("Enter
    the element: "))

   stack.append(float_element)

   print(stack)

   elif user_choice == 3:

   string_element = input("Enter the
    element: ")

   stack.append(string_element)

   print(stack)

   elif user_choice == 4:

   bool_element = int(input("Enter the
    element: "))

   if bool_element >= 1:

   stack.append(True)

   print(stack)

   elif bool_element < 1:

   stack.append(False)

   print(stack)

   elif user_choice == 0:

   break

   else:

   print("Enter correct operations..")

def pop_element():

   if not stack:

   print("Stack is empty.")

   else:

   e = stack.pop()

   print("Removed element:",e)

   print(stack)
while True:

   print("Select the operations: 1.push 2.pop 3.quit")

   choice = int(input("Enter your
    choice: "))

   if choice == 1:

   push_element()

   elif choice == 2:

   pop_element()

   elif choice == 3:

   break

   else:
   print("Please select the correct
    operations.")

In this example you can see 2 functions are used, one for pushing value and another for deletion.

Here also you can see infinite while loop is running in which the conditions are generating and asking for the input, you can also end program by the quit buttons.

Output of the program is:

  Select the operations: 1.push 2.pop 3.quit
Enter your choice: 1

  select the option to take input:

  1.Int 2.Float 3.String 4.Bool 0.quit

  Enter choice to push the element: 1
Enter the element: 23
[23]

  select the option to take input:


  1.Int 2.Float 3.String 4.Bool 0.quit


  Enter choice to push the element: 2

Enter the element: 23.4
[23, 23.4]

  select the option to take input:


  1.Int 2.Float 3.String 4.Bool 0.quit


  Enter choice to push the element: 3


  Enter the element: "CodeWithDevops"

[23, 23.4, '"CodeWithDevops"']

  select the option to take input:


  1.Int 2.Float 3.String 4.Bool 0.quit


  Enter choice to push the element: 4

Enter the element: 1

  [23, 23.4, '"CodeWithDevops"', True]


  select the option to take input:


  1.Int 2.Float 3.String 4.Bool 0.quit


  Enter choice to push the element: 0


  Select the operations: 1.push 2.pop 3.quit

Enter your choice: 2
Removed element: True
[23, 23.4, '"CodeWithDevops"']

  Select the operations: 1.push 2.pop 3.quit

Enter your choice: 3

Now let's see collections, collections are in built library in Python, it contains queue and their methods to solve these kind of problems.

To use collections you have to import this module inside your program. If you are familiar with Java then you know importing libraries, basically import is a keyword that helps our program to use Python pre-defined libraries and modules.

First import collections and from this collection use deque method to solve stack problems.

Let's see an example to understand:-

import collections
stack = collections.deque()
print(stack)
stack.append(10)
stack.append(20)
stack.append(30)
stack.append(40)
stack.append(50)
print(stack)
print("Removing ",stack.pop())
print("Removing ",stack.pop())
print("Removing ",stack.pop())
print(stack)

As you can see above example in first line collections module is imported, then a empty list is created by a method of collections called deque().

as you know that to append values inside list you have to use append method, o use it and insert values inside stack list.

To remove the value same as above you seen use pop method.

Output of this program will be:-

deque([])

deque([10, 20, 30, 40, 50])

Removing 50

Removing 40

Removing 30

deque([10, 20])

Next thing is queue module this is also used to solve stack problem, import queue module, from the module you have to use LifoQueue method to solve the stack problem. Let's understand this problem with an example:-

import queue
stack = queue.LifoQueue()
stack.put(10)
stack.put(20)
stack.put(30)
stack.put(40)
stack.put(50)
print(stack)
stack.get()
stack.get()
stack.get()
print(stack)

As you can see this problem first queue is imported then LifoQueue is used from queue module(you can also give some value inside LifoQueue's braces as limit of the stack) then LifoQueue provides put() and get() methods instead of append and pop methods put method append the value and get method removes the value.

Output will be:-

  <queue.LifoQueue object at 0x000001BE5FEDAFA0
50
40
30
  <queue.LifoQueue object at 0x000001BE5FEDAFA0>

As you can see queue is an object so you cannot print it, that's why is showing the memory location instead of list.

That's it for this blog we will continue with Queue data structure in next blog.

Introduction to Data Structure in Python

2022-03-13T10:36:00.053+05:30

Today engineers are hired on the basis of problem solving skills, for that you need to know Data structure for sure.

In this blog you should be aware of what is data structure and what is use of it in programming world..

Note:- In this and upcoming blogs you will learn data structure with Python Programming Language

So let's get started:

If you learn Data structure with python it will be a lot more easy to learn, if you don't understand let me show you:-

Python have built in data structures that will do your half of work very easily, they are as following:-

1> List :-

List is upgrade version of the arrays, in python if you want to use array you will have option of array that will be some tricky for you cause you have to use numpy for that but there is easier thing available for you i.e. List.

A list is collection of element that you can store in it. In arrays you can store only integer at a time but in list you can store any data type.

An array has a limited size so you have to see size in your number storing but list is dynamic it does not have fixed size so you can store n number of data inside your list.

List is mutable so you can change, add and remove elements after printing list.

List also allows Duplicacy.

List's example is:-


  myList = [1,2,3,4,5,6.5,7.6,8.7,"Hi","CodeWithDevops",True]

2> Tuple

Tuple is also a collection in Python use to store values inside it. It also can store duplicate values inside it and tuple is immutable so you cannot change after printing tuple.

Tuple's example is:-


  myTuple = (1,2,3,4,5,6.5,7.6,8.7,"Hi","CodeWithDevops",True)

3> Set

Set is also the same as the above two but it does not allow duplicacy and it is also immutable but it can be updated.

Set's example is:-


  mySet = {1,2,3,4,5,6.5,7.6,8.7,"Hi","CodeWithDevops",True}

4> Dictionary

Dictionary is also use to store values inside it but in key and value pair. In dictionary key should be always unique and value can be unique or not doesn't matter.

myDict = {
"name" : "CodeWithDevops",
  "job" : "Helping others with blog",
"fav_lang" : "Python"
}

That is it that much of data structure Python provides us inside it, but you can use many more data structures.

These data structures were called as Built-in Data Structure.

What we will be seeing next be User-defined Data Structure.

Methods to Increase your Internet Speed

2022-03-13T09:30:00.000+05:30

In Today's Generation, the demand of internet is getting at a hype level. Everything is getting online; shops, stores, foods, groceries and much more.

Sometimes, we have a good enough Internet Connection; but it's not adjustable. Sometimes Internet Speed gets decreased by many technical reasons i.e. Cache, DNS, DHCP, etc.

In this Article, I am Gonna Demonstrate you 3 Methods How to Increase your Internet Speed Via Command Prompt in Easy Way.

1. Renew IP Address :

In this Method, We Actually have to renew IP Address of our System to get rid of slow internet speed.

To do this method, you just have to simply open Command Prompt (Run as Administrator) or Just Navigate it through Start Menu (Run as Administrator).

After Opening, type the following command.

ipconfig/release

wait for sometime and let the process get complete. After this, type the second command.

ipconfig/renew

You're Done. Restart your System for Enhanced Experience.

Why Is it Important to do?

Answer: Sometimes, after browsing lots of things on a system - the system collects huge size of cache and that's the reason of getting internet speed at slow level. You Can call it as a "IP Conflict" or DHCP.

2. Flush DNS Resolver Cache :

In this Method, We Have to Flush the DNS Cache stored automatically by system while surfing.

To do this Method, Simply Open Command Prompt (Run as Administrator) on your Desktop and Type the Following Command.

ipconfig/flushdns

You're Done ! You Can Now Restart your System for Enhanced Experience.

Why is it Important to do?

Answer: The System Automatically Stores the List of Website's Hostnames and IP Addresses which you visit and save it as DNS Resolver Cache. So, it becomes necessary to flush DNS Cache time-to-time.

3. Reset Winsock :

In this Method, We have to reset the WinSock; which actually is a programming application which handles input/output request for Internet Applications. So, to do this method - open Command Prompt (Run as Administrator) and type the following command.

netsh winsock reset

You're Done ! Now it's Compulsory to Restart your System for Enhanced Internet Experience.

Why is it Important to do?

Answer: Microsoft Windows uses Multiple Network Sockets to Exchange Information. And the User-Run Programs or Sites can Auto-Install LSP (Layered Service Provider) and if there's a technical issue then LSP can make your system internet speed slow.

Hope you like the Article ! Please Share with your Connections and let Everyone Know about this Cool Hacks for Enhancing Slow Internet Speed.

If you want to watch the same Article as a Video Tutorial. Please Watch the Video Embedded Below.

What is WordPress

2022-03-12T09:20:00.000+05:30

In this Article, We'll Know About: What is WordPress and Uses, History and Benefits of it.

What is WordPress?
On the Internet, Almost 30% of Websites or Blogs are installed on WordPress.

WordPress is an Open Source Software Tool that is used to create, manage, edit, publish websites and blogs as per user requirement. Generally, WordPress is a Content Management System (CMS) that manages all the content of the Websites.

Taking you in the Depth in Creation of WordPress; it is built-in PHP and MySQL Languages and was publicly launched in 2003 on 27th May.

The Popularity of WordPress is the tool to create and manage websites. As per Reports, WordPress Claims that almost 30% Websites are built in WordPress.

Remember, the Basics of WordPress:

WordPress is Open Source and Free Tool to Create an Website.

Why is WordPress Used?

WordPress is mainly used for Creating Blogs, Websites, E-Commerce, Personal Blogs and Much More...

As I told, Almost 30% of Websites are built on WordPress.

Is WordPress Free?

Yes (Partially), WordPress is absolutely free and open source tool for everyone. Although, they have different plans as per different features.

In Basic plan, you'll get 'Wordpress.com' sub-domain and you can create free blog, website through it and you can choose many of free themes available in the basic plans.

For More: Check Plans Here

If you want to add custom domain and monetize your site you've to go for the paid plans.

Is Coding Skills Needed?

Creating a Website in WordPress doesn't need any coding skills, you must have creative skills to built website dynamically. WordPress has a Virtual Builder for Creating Websites. You Just have to Drag, Drop, Edit.

Types of WordPress:

1. WordPress.org

2. WordPress.com

Benefits or Advantages of Using WordPress:

1. Access to Bunch of Plugins (60,000+). (Paid Plan)

2. Unique or Custom Domains (Paid Plan) and Sub-Domains (Free Plan)

3. Monetize your Site with Ads like Third-Party Advertisers like AdSense. (Paid Plans)

4. Complete Customization on your Website.

Remember, WordPress is Paid + Free: It depends on your needs that Is it Free for You or Paid for using unlimited features and control.

In-Brief about WordPress:

WordPress (WP, WordPress.org) is a free and open-source content management system (CMS) written in PHP and paired with a MySQL or MariaDB database. Features include a plugin architecture and a template system, referred to within WordPress as Themes. WordPress was originally created as a blog-publishing system but has evolved to support other web content types including more traditional mailing lists and forums, media galleries, membership sites, learning management systems (LMS) and online stores. WordPress is used by 41.4% of the top 10 million websites as of May 2021,WordPress is one of the most popular content management system solutions in use. WordPress has also been used for other application domains, such as pervasive display systems (PDS).

WordPress was released on May 27, 2003, by its founders, American developer Matt Mullenweg[1] and English developer Mike Little, as a fork of b2/cafelog. The software is released under the GPLv2 (or later) license.

To function, WordPress has to be installed on a web server, either part of an Internet hosting service like WordPress.com or a computer running the software package WordPress.org in order to serve as a network host in its own right. A local computer may be used for single-user testing and learning purposes.

Themes in WordPress:

WordPress users may install and switch among different themes. Themes allow users to change the look and functionality of a WordPress website without altering the core code or site content. Every WordPress website requires at least one theme to be present and every theme should be designed using WordPress standards with structured PHP, valid HTML (HyperText Markup Language), and Cascading Style Sheets (CSS). Themes may be directly installed using the WordPress "Appearance" administration tool in the dashboard, or theme folders may be copied directly into the themes directory, for example, via FTP.[14] The PHP, HTML and CSS found in themes can be directly modified to alter theme behavior, or a theme can be a "child" theme that inherits settings from another theme and selectively overrides features. WordPress themes are generally classified into two categories: free and premium. Many free themes are listed in the WordPress theme directory (also known as the repository), and premium themes are available for purchase from marketplaces and individual WordPress developers. WordPress users may also create and develop their own custom themes. The free theme Underscores created by the WordPress developers has become a popular basis for new themes.

Plugins in WordPress:

WordPress' plugin architecture allows users to extend the features and functionality of a website or blog. As of May 2021, WordPress.org has 58,463 plugins available, each of which offers custom functions and features enabling users to tailor their sites to their specific needs. However, this does not include the premium plugins that are available (approximately 1,500+), which may not be listed in the WordPress.org repository. These customizations range from search engine optimization (SEO), to client portals used to display private information to logged-in users, to content management systems, to content displaying features, such as the addition of widgets and navigation bars. Not all available plugins are always abreast with the upgrades, and as a result, they may not function properly or may not function at all. Most plugins are available through WordPress themselves, either via downloading them and installing the files manually via FTP or through the WordPress dashboard. However, many third parties offer plugins through their own websites, many of which are paid packages.

Web developers who wish to develop plugins need to learn WordPress' hook system which consists of over 2000 hooks (as of Version 5.7 in 2021) [divided into two categories: action hooks and filter hooks.

Plugins also represent a development strategy that can transform WordPress into all sorts of software systems and applications, limited only by the imagination and creativity of the programmers. These are implemented using custom plugins to create non-website systems, such as headless WordPress applications and Software as a Service (SaaS) products.

Plugins also could be used by hackers targeting the site that use WordPress, as hackers could exploit bugs on WordPress plugins themselves instead of exploiting the bugs on WordPress itself.[19]

Mobile applications:

Phone apps for WordPress exist for WebOS, Android, iOS, Windows Phone and BlackBerry. These applications, designed by Automattic, have options such as adding new blog posts and pages, commenting, moderating comments, replying to comments in addition to the ability to view the stats.

Accessibility:

The WordPress Accessibility Team has worked to improve the accessibility for core WordPress as well as support a clear identification of accessible themes. The WordPress Accessibility Team provides continuing educational support about web accessibility and inclusive design. The WordPress Accessibility Coding Standards state that "All new or updated code released in WordPress must conform with the Web Content Accessibility Guidelines 2.0 at level AA.

Other features:

WordPress also features integrated link management; a search engine–friendly, clean permalink structure; the ability to assign multiple categories to posts; and support for tagging of posts. Automatic filters are also included, providing standardized formatting and styling of text in posts (for example, converting regular quotes to smart quotes). WordPress also supports the Trackback and Pingback standards for displaying links to other sites that have themselves linked to a post or an article. WordPress posts can be edited in HTML, using the visual editor, or using one of a number of plugins that allow for a variety of customized editing features.

Setup Auto-Refresh on Blogger Platform

2022-03-11T08:56:00.000+05:30

Hello Audience, In this Article I will show you how to enable auto-fresh in your Blogger Blog in very simple steps.

If you're still unknown to What Auto-Refresh in Blogger is then there's nothing to worry. I will explain you each and every detail of auto-refresh in Blogger.

Note- You Can Also Use this Trick in WordPress.

Auto-Refresh itself means that it will auto-refresh your blog in the set-timer.

So, Let's get Started...

Step-By-Step Procedure

Step 1 - Head to Blogger Dashboard > Themes > Edit HTML

Step 2 - Copy and Paste this Code in between <head> and </head> tag of your blogger theme.

<meta content='60' http-equiv='refresh'/>

Note- The Text Marked with Green Colour in the Timer (Seconds). It's By Default "60" Seconds.

Step 3 - Click SAVE.

Step 4 - You're Done.

Let's talk about the Advantages and Disadvantages of Auto-Refresh on Blogger.

Advantages :-

Mainly, you can say there are 3 advantages of auto-refresh in Blogger.

It will Increase the Visitor's Count and Increase Traffic in your Blog.
It will help you to rank your blog/website in Google Search Engine.
If you're AdSense User, It will increase your Earning via auto-refreshing and showing new Ads each time to the User.

Point No.2 (refer), Ranking of Website or Blog in Google Search Engine; directly means that auto-refresh will replicate the same user again and again; Google will think there's something interesting and will rank your Blog-Post at the top in Search Engine. I Know Google's AI are very strong, but if you keep your auto-refresh timer on 60 Seconds which is by-default then it will not be manipulating.

Disadvantages :-

There are not such serious disadvantages with the Auto-Refresh in Blogger; until and unless you have set the timer too fast.

If you set the Timer too fast then it will auto-refresh often in every while. My Recommendation is to set the timer to 60 Seconds.

If you Set the Timer very fast then, Google will think you're Manipulating Traffic and you're blog may be black-listed and banned from Google AdSense.

So, If any query - Comment Below !

Thank You.