DEV Community: Joshua Wainaina

Use geopy to calculate the distance between two points

Joshua Wainaina — Tue, 23 Jun 2026 12:19:24 +0000

The Geopy method for distance calculation between any two points on the globe.

Introduction.

Geopy is essentially a Python library that makes the calculation of geographic distances unchalleging. It becomes considerably easier for developers using Geopy to retrieve the coordinates of various sites by leveraging third-party geocoders and other data sources.

In this article, we'll look at a few alternative ways for calculating the distance between any two points on the globe. We shall dig deep to explain how this is possible using Python package geopy which is the primary Python package for distance calculation.

The user needs first to execute the following command to install geopy.

Before executing the command below, there is a series of steps that are followed so that the command is finally arrived at.

Open your cmd and make sure it is running as an administrator.
Make sure that you are operating from the root by performing the following. cd..
cd.. This shows that you are already at the root.
After that now you can perform the command below and geopy will be installed in your machine.

pip install geopy

We are therefore set to calculate the distances of any two points following a successful installation of the geopy module.

Using the Geopy, we can calculate or find the distance between two strategic positions using the various methods that are listed below.

Distance Measure using the Geodesic Measure.
Distance Measure using The greate circle distance.
Distance Measure using The Herversine formula. ### The Geodesic Measure for distance calculation. The geodesic measure or distance is used to define the shortest path between any two given points on the globe.

As in the situation of two diametrically opposing points on a sphere, it is feasible that numerous alternative arcs between two points reduce the distance. In this case, any of these curves is a geodesic. Geodesics are not exactly the same as " the shortest curves" between any two given locations, despite their likeness.

It is rather defined in a better way as the shortest distance between two points at a given position that is parameterized with "constant speed." A geodesic is the "long way around" on a great circle between two points on an earth's surface, even if it is not the shortest path between the two points.

An important point to note when working with geodesic or when calculating any distance between any two points on the sphere is that it does not ignore any curved part. In contrast to this, a distance calculation known as Euclidean distance completely ignores the shape of the path that is involved such that it assumes a straight path from the start of a point to its end.

We'll illustrate how to compute or how to calculate the Geodesic Distance using latitude and longitude data in the following example.

Example 1.1

# To begin, open the geopy library and import the geodesic module. 
from geopy.distance import geodesic as GD
 # Then, for the specified locations, load their latitude and longitude data.
Abuja =(9.072264 , 7.491302)
Dakar =(14.716677 , -17.467686)
#Finally, print the distance between two sites in kilometers.
print("The distance between Abuja  and Dakar is:", GD(Abuja, Dakar).km)

See terminal output below:

The distance between Abuja  and Dakar is: 2787.8012928541466

Example 1.2

# Geopy distance module is first imported for the purpose of computations.

from geopy.distance import geodesic as GD
# Next, input the latitude and longitude data for Nairobi and Cairo.  

Nairobi=(36.817223,-1.286389 )
Cairo=( 31.233334,30.033333, )
# Finally, print the distance between two sites in kilometers. 

print("The distance between Nairobi and Cairo is :",GD(Nairobi,Cairo).km)

See terminal output below:

The distance between Nairobi and Cairo is : 2944.261368793268

The outputs from the two examples above are obtained by loading the latitude data first then the longitude data. If we try to exchange the order in which the two are loaded i.e we load the longitude data first then the latitude data last, the distance obtained will not be equal with the original distance. Let us have a proof on that by using the data in example 1.1 above.

# To begin, open the geopy library and import the geodesic module. 
from geopy.distance import geodesic as GD
# Then, for the specified locations, load their longitude and latitude data
Abuja=(7.491302, 9.072264 )
Dakar=(-17.467686, 14.716677)
#Finally, print the distance between two sites in kilometers.
print("The distance between Abuja and Dakar is:", GD(
Abuja, Dakar).km)

See terminal output below:

The distance between Abuja and Dakar is: 2829.4255581410116

The comparison is as follows:

The distance between Abuja  and Dakar is(Latitude data first followed by longitude data): 2787.8012928541466

The distance between Abuja and Dakar is (Longitude data first followed by the latitude data): 2829.4255581410116

It is very clear that the two distances are not the same. And this will apply to all other methods and it is, therefore, a good practice to begin with the latitude data followed by the longitude data

The great circle distance formula for distance calculation.

This may be defined as the shortest path between any two places or points on the sphere or on the earth's surface. In this example, it is assumed that the globe is a perfect sphere. The following example shows how to compute great circle distance using longitude and latitude data from two locations.

The problem of great-circle navigation includes the computation of azimuths at end points and intermediate waypoints, as well as the calculation of the great-circle distance.

A great circle is formed by any two points on a sphere that are not directly opposite with each other. The great circle is divided into two arcs by these two locations. The shorter arc that is between any two locations equals to the great-circle distance.

Example 1.3

 # First, import the geopy library's great circle module.
from geopy.distance import great_circle as GRC
# Abuja and Dakar latitude and longitude data.
Abuja=(9.072264 , 7.491302)
Dakar=(14.716677 , -17.467686)
# ## Finally print the distance between the two points calculated in km
print("The distance between Abuja  and Dakar is:", GRC(Abuja,Dakar).km)

See terminal output below:

The distance between Abuja  and Dakar is: 2785.186971064666

The Heversine formula for distance calculation.

The heversine formula executes the great-circle distance between any two points on a sphere using their longitudes and latitudes.

One specific example is the rule of haversines, a more general formula in the field of spherical trigonometry that connects the sides and angles of spherical triangles.

The haversine method therefore gives a very correct way of finding the distance between any two given longitude and latitude.

The haversine formula is a realignment of the spherical law of cosines, although it is more useful for tiny angles and distances since it is written in haversines.

The "Ha" in "Haversine" represents "half versed sine," and haversin(θ) = versin(θ)/2 is the formula.
The orthodromic distance is used to calculate the shortest distance between two sites on the globe separated by latitude and longitude.

If the user want to utilize this method, then they must have the coordinates of two points (X and Y).
They must convert degrees of latitude and longitude to radians before dividing the data by (180/π) and the value of π to be used is 22/7.

"57.29577" will be the value of (180/π).

The user may wish to find the distance in miles where the radius of the Earth can be set to "3,963." The user can also use the value "6,378.80" to compute the distance in Kilometres.

Formulas

Longitude in radians is calculated as follows: In radians, the value of latitude is: Latitude (LaA) = LaA / (180/π )

Latitude (LaA) = LaA / 57.29577
How to compute longitude in radians:
Longitude (LoA) = LoA / (180/π )

Longitude (LoA) = LoA / 57.29577

The longitude and latitude coordinates of P and Q locations, as well as the aforementioned method to convert them to radians, will be required by the user.

By utilizing the following method, distance between any two points can be found.

Hundreds of miles

Distance (D) = 3963.0 * arccos[(sin(LaA) * sin(LaB)) + cos(LaA) * cos(LaB) * cos(LoB - LoA)]

For the kilometer

Distance (D) = 3963.0 * arccos[(sin(LaA) * sin(LaB)) + cos(LaA) * cos(LaB) * cos(LoB - LoA)]

For the kilometer: The shortest distance between two specified points on Earth can be calculated using the Haversine Formula.

Example 1.4

from math import radians, cos, sin, asin, sqrt

# Implement the formula below

def distance_d(LaA, LaB, LoA, LoB):
# The function "radians" is found in the math module, It's also used to convert radians to degrees.  
LoA = radians(LoA)  
LoB = radians(LoB)  
LaA= radians(LaA)  
LaB = radians(LaB) 
# The "Haversine formula" is used.
D_Lo = LoB - LoA 
D_La = LaB - LaA 
P = sin(D_La / 2)**2 + cos(LaA) * cos(LaB) * sin(D_Lo / 2)**2  

Q = 2 * asin(sqrt(P))   
    # The earth's radius in kilometers.
R_km = 6371  
# Then we'll compute the outcome.
return(Q * R km).


LaA=9.072264
LaB=14.716677
LoA=7.491302
LoB=-17.467686

print ("The distance between Abuja and Dakar is: ", distance_d(LaA, LaB, LoA, LoB), "K.M")

See terminal output below:

The distance between Abuja and Dakar is:  2785.183036572855 K.M

Conclusion

Using the geopy package, we've gone over numerous ways for determining the distance between two points on the earth's surface in this tutorial. Each approach has been demonstrated using examples.
Happy Coding

Adding custom methods for linq queries

Joshua Wainaina — Tue, 23 Jun 2026 12:15:36 +0000

Adding custom methods for LINQ queries (C#)

Introduction

By introducing extension methods to the IEnumerableT> interface, you may expand the set of methods available for LINQ queries. Any data sequence can be converted into one single value by creating your custom aggregate method in SQL Server.

You can also build a method that returns a new series of values and acts as a custom filter or a specialized data transform for a sequence of variables.

A few examples include the Distinct and Skip techniques, as well as the Reverse.

You may apply your methods to any enumerable collection when you extend the IEnumerableT> interface. In this article, we shall deeply take a look at various custom methods that are used in LINQ queries in C#.

Adding an aggregate method

When a set of values is aggregated, a single value can be generated. Average, Min, and Max are just a few of the aggregate techniques available in LINQ. By introducing an extension method to the IEnumerableT> interface, you can design your aggregate method.

Median is an extension method that computes the median of a sequence of double-valued numbers.

public static class LINQExtensionExample
{
    public static double Median(this IEnumerable<double>? source)
    {
        if (!(source?.Any() ?? false))
        {
            throw a new InvalidOperationException("A null or empty set cannot be used to compute the median..");
        }

        var sortedList = (from numberX in source
                          orderby numberX
                          select numberX).ToList();

        int itemIndex = sortedList.Count / 2;

        if (sortedList.Count % 2 == 0)
        {
            // Rerurning an even number of objects or items
            return (sortedList[itemIndex] + sortedList[itemIndex - 1]) / 2;
        }
        else
        {
            // Rerurning an odd number of objects or items
            return sortedList[itemIndex];
        }
    }
}

There is no difference between calling this extension method from the IEnumerableT> interface and calling any other aggregate function.

On a double array, the following code demonstrates using the Median method

double[] numbers1 = { 0.9, 5, 2, 9.3, 2.6, 7, 3.3, 4 };

var query = numbers1.Median();

Console.WriteLine("double: Median = " + query1);
/*
 The output of the above code is as shown below

 Double: Median = 5.95
*/

An aggregate method is overloaded by accepting a variety of types.

To accept sequences of different types, you can overload your aggregate method. Overloading each type is the typical technique. It's also possible to use a delegate to build an overload for a generic type. Combining both approaches is also an option.

To build a type overload

A separate overload for each kind you want to support can be created. Here's an int-type overload of the Median method, which you can see in the following code example.

//Overload of int
public static double Median(this IEnumerable<int> source) =>
    (from numX in source select (double)numX).Median();
With the new Median overloads available for both integer and double types, the following code shows how to use them:
double[] numbers2 = {  0.9, 5, 2, 9.3, 2.6, 7, 3.3, 4};

var query2 = numbers2.Median();

Console.WriteLine("double: Median = " + query2);

int[] numbers3 = { 14, 16, 15, 13, 11, 10, 9 };

var query3 = numbers3.Median();

Console.WriteLine("int: Median = " + query3);
/*
 Here's what it looks like when it runs:

 The Double part: Median = 5.95
 The Integer part: Median = 13
*/

Initiating a generic overflow

A list of generic objects can also be used as an input to an overload if you want to do that. Delegate is supplied as a variable in this overload which converts the generic objects into a specific type using the delegate.

An overload of Median's FuncT,TResult> delegate is shown in the following code. An object of generic type T is passed to this delegate, and it returns a double-type object as a result.

// Let us take a look
public static double Median<T>(this IEnumerable<T> numbersY,
                       Func<T, double> selector) =>
    (from num in numbersY select selector(num)).Median();

When working with sequences of objects of any type, you may now use the Median technique. A delegate parameter must be passed in if the type does not have its overload of the procedure. Lambda expressions are available in C# for this purpose. When using Aggregate or Group By clauses instead of a method call, this is only true in Visual Basic.

You can use the following code to call the Median method on a string array as well as an integer array. Using an array of strings, a median is derived for each string's lengths in the array. Use the Median method's delegate parameter for each scenario in the code. Use the Median method's delegate parameter for FuncT, TResult> for each scenario in which it's used.

int[] numbers4 = { 14, 16, 15, 13, 11, 10, 9 };

/*
   In this case, the compiler will implicitly convert num=>num's value to double when you pass it as a parameter to the Median method.
   Otherwise, the compiler will give the user an error message.
*/
var query4 = numbers4.Median(num => num);

Console.WriteLine("int: Median = " + query3);

string[] numbers5 = { "fourteen", "sixteen", "fifteen", "thirteen", "eleven", "ten", "nine" };

// A number of object properties are available with the generic overload.

var query5 = numbers5.Median(str => str.Length);

Console.WriteLine("String: Median = " + query5);

/*
Here's what it looks like when it runs:
 Integer: Median = 13
 String: Median = 13
*/

Adding a method that returns a sequence

IENumerableT can be extended with custom query methods to return a sequence of values. A collection of IEnumerableT> must be returned in this scenario. Filters or data transformations can be applied to a sequence of values using these methods.

Using the AlternateElements Extension Method, every other element in a collection, starting with the first element, is returned.

//The IEnumerableT> interface has an extension method.
// Every other element in a sequence is returned by the method.
public static IEnumerable<T> AlternateElements<T>(this IEnumerable<T> source)
{
    int y = 3;
    foreach (var element in source)
    {
        if (y % 2 == 1)
        {
            yield return element;
        }
        y++;
    }
}

This function can be used to extend any enumerable collection.

string[] strings = { "u", "v", "w", "x" };

var query4 = strings.AlternateElements();

foreach (var element in query6)
{
    Console.WriteLine(element);
}
/*
Here's what it looks like when it runs:
 u
 w

*/

Conclusion

In conclusion, we have looked at how one as a programmer can add custom methods for LINQ queries in c#.

Key differences between python and javascript

Joshua Wainaina — Tue, 23 Jun 2026 11:53:18 +0000

Key differences between python and JavaScript

Introduction

Python and JavaScript are important languages that are used in web development. Python is a language that can be used in the backend development of a web application. JavaScript on the other hand is a language that can be used in both the frontend and backend development of a web application.

However, despite the difference in development part that each language plays, the two languages have other big differences that we are going to look into detail in this article.

Real World application of Python and JavaScript.

Python is mostly used in scientific and specialized applications as it is also used in web development.

JavaScript is widely used in web development.

Syntax, Sentactical and Functional differences between Python and JavaScript

Python and Js have different Syntax.
Python and JavaScript have some key differences in terms of the syntax used in performing various activities.

Code blocks in python and JavaScript

In Python, when several lines of code are indented, then they are said to be of the same code block.

Example

if  t  > 10:

     print (t)

In JavaScript, notwithstanding, wavy supports are utilized rather than space to bunch explanations that have a place with a similar code block.

Let's look at an example.

if (t>10)

{

    console.log(t)

}

Definition of variables

When defining a variable in python, a variable name is written followed by an equal (=) sign. Then a value is assigned to the variable. i.e

<variable_name > = value

x = 56

In JavaScript, a keyword var is added before the variable name and a semicolon is used to terminate the statement i.e

var <variable_name>  = value;

eg  var k=34;

Variable Naming Conventions

In Python, the snake_case naming style is used. The names should be in lowercase and separated by an underscore as shown below.

first_name

In JavaScript, lowerCamelCase is used. The variable name starts with a lowercase letter and every other new word starts with an uppercase letter.

myFirstName

Constants in Python and JavaScript.

Constants

In Python, constants are written in uppercase format separated by an underscore. ie. CONSTANT_NAME.

For example:

PASS_RATE = 4

In JavaScript, a keyword const is added before the constant name and a semicolon is used to terminate the statement. ie. const CONSTANT_NAME = value;

const AGE=56;

Data types and values in Python and JavaScript

1) Numeric data types

In python, we have three numeric sorts that will assist us with accomplishing exact estimations for logical purposes. These are :

In JavaScript, we have two numeric types i.e Numbersand BigInt. The two whole numbers and coasting point numbers are viewed as type numbers.

None and null in python and JavaScript

In python, when a variable doesn't have a worth at a specific point in the program, it is alloted an extraordinary worth called None.

In JavaScript, the same worth is null which addresses the shortfall of any item esteem.

The undefined value

In python, one needs to allocate an underlying worth to the variable. One cannot declare a variable without an initial value.

In Javascript, we have a unique worth that is allocated consequently. When a variable is declared without assigning an initial value, it prints out undefined as shown below;

var k; // should print undefined

Primitive data types

Python have four primitive data types:

Intergers.
float.
boolean (https://www.codesansar.com/python-programming/fundamental-or-primitive-data-types.htm#bool).
strings.

On the other hand, JavaScript have six primitative data types:

Comments

Commenting is done for any reason. For example, one may comment on a line for future reference.

1. Single-line comments

Comment spanning a single line. Look at the example below:
In python, a hashtag (#) is used to comment on a single line.

# this is a  single-line comment in python

As shown above we have used a hashtag(#) to comment on a single line in Python.

In JavaScript double slashes (//) are used to comment on a single line.

//this is a single-line comment in JavaScript

As shown above we have used double slashes (//) to comment on a single line in JavaScript.

2. Multiple line comments

These are comments spanning many lines.

When writing multiple comments in python, we start every single line with a hashtag (#) as shown below:

# this is a   
# multiple lines 
# comment
# as used in Python`

When writing multiple line comments in JavaScript, we use symbols (/*) to open and (*/) to close a comment as shown below:

/*
 This is  a multi-line comment
that span many lines
*/

Built in data structures

1. Tuples

Tuples in Python are similar to lists but immutable.
They are utilized to store information that ought not be changed

In JavaScript, we don't have an inherent construction with such qualities.

2. List and Arrays-->

Records are utilized in python to store a progression of qualities in a similar information structure

number = [3, 4,5]

An array is the equivalent version of this in JavaScript.

var number = [3,4,5]

Comparing values and types

In Python the double equal (==) operator are used to compare if two values and their data types are equal -->

11 == 11 #True
11 == 10 #False

javascript
As shown above, 11 == 11 is true, while11 != 10 is false.

In JavaScript, a triple equivalent ('===') administrator is utilized to look at if two qualities and their information types are equivalent.

5===5  //true
5==='5'  //false

Logical Operators

In python, there are three logical operators:

In JavaScript, the logical operators are also three:

&& -- logical and.
|| -- logical or.
! --logical not. ### Type Operators To check the type of object in python we use the (type()) function as shown below:

type(instance)

To check the type of object in JavaScript we use type of operator as below:

type of instance

Inputs and Outputs

Input is a function that is used to ask the user of the program a question whereby the user have to type the result of the asked question.

Output on the other hand is used to print the specific message that the user inputs.

Inputs

In python input() function is used to ask for user input.

Example

name = input (" Enter your name : ")

In JavaScript, (if you are running your code on console ) it will display a small prompt with window. prompt (message) and assign the result to a variable.

var input =window.prompt ("enter a Number :")

Outputs

In python we print a worth in the comfort with the print() work parsing the qualities inside the enclosure.

Example

num1 = input ("Enter the first  number : ")
num2 = input ("Enter a second  number : ")
num3 = input ("Enter a third number : ")
result= num1 + num2 + num3
print(result)

In JavaScript, we print a value in the console with the print() function parsing the values within the parenthesis.

Example

console.log("My name is John:");

Conditional statements

Conditional statements are used to act if a certain condition is true.

1. if statement

In python, indentation is relied upon to indicate the lines of code that belong to a conditional statement.

if condition:

     code

Let's look at an example:

age = 10
if age < 18:
    print('kid you are!')

In JavaScript, the condition is enclosed in parenthesis and the code enclosed within curly braces which should also be indented as shown in the syntax below:

if (condition)

    {
        code
    }

An example of a snippet would look like:

if (hour > 4) {
  task = "Clean the compound";
}

if else statement

In python, a colon (:) is written after the else keyword.

if condition:

    if code

else :

    else code

Let's look at an example:

age = 34
if age < 18:
    print('kid you are!')
else:
    print('You are not a kid')

In JavaScript, the code that belongs to the elseclause is enclosed in curly braces.

if (condition)

    {
        if code
    }

else 

    {
        else code
    }

Let's look at an example.

var time = new Date().getHours();
if (time < 5) {
  task = "Cleaning the house";
} else {
  task = "Feeding the sheep";
}

Multiple conditions

In python elif keyword is used when dealing with multiple conditions. After every condition we write a semicolon(:) and the code that belongs to the condition is indented in the next line.


if condition1:

    code

elif condition2:

    code

elif condition3:

    code

else:

    code

Let's look at an example.

age = 40
if age < 18:
    print('kid you are!')
elif age >=18 and age < 29:
    print('You are a youngst!')
elif age >=29 and age < 35:
    print('You are middle aged!')
else:
    print('You are above middle age !')

In JavaScript else if keyword is used when dealing with multiple conditions. The conditions are surrounded by parenthesis.

if(condition1)

    {
        //code
    }

else if(condition2)

    {
       // code
    }

else if (condition3)

    {
        //code
    }

else

    {
        //code
    }

Let's look at an example.

var time = new Date().getHours();
if (time < 5) {
  task = "Cleaning the house";
} else if (time < 15) {
  task = "Feeding the sheep";
} else {
  task = "Watching a movie";
}

Switch

Python does not have this type of built-in control structure i.e switch

In JavaScript, a switch is utilized to pick what happens depends on the worth of an articulation.

switch(expression)

    {
        case 1:
        code
        break;

        case 2:
        code
        break;

        case 3:
        code
        break;

        default:
        code
    }

Let's look at an example.

switch (new Month().getMonth()) {
  case 1:
    month = "January";
    break;
  case 2:
    day = "April";
    break;
  case 3:
     day = "May";
    break;
  case 4:
    day = "June";
    break;
  case 5:
    day = "August";
    break;
  case 6:
    day = "September";
    break;
  default:
  No such a month;
}

Loops

A loop is a control structure that repeats a series of instructions until a specified condition is reached.

For Loops

We write a for loop in Python as shown below.

for x in range(k):

    code

The syntax of writing a for loop in JavaScript is as follows.

for(var x = 1; x >n ; x++)

{

        code
}

While Loop

It is a pre-test loop in which the condition is evaluated before the loop executes.

In Python, we compose the watchword while trailed by the condition, and afterward, a colon (:), and afterward the body of the circle in another line in an indented mode.


while condition: code

In JavaScript, the linguistic structure is the same. The distinctions are that we need to encompass the condition with enclosures and the body of the circle with wavy supports.

while(condition)

{

    code

}

Do while loops

This is a post-test loop. The condition is evaluated after the loop executes

In python, we do not have such a control structure (do-while loop)

In JavaScript, this loop will always be executed
once.


do { code } while (condition);

Functions

A Function is a block of code that plays out a specific undertaking. In Python, we utilize a watchword def which is trailed by the name of the function. Then the parameters are enclosed in parenthesis and then a full colon immediately after the parameters are enclosed in parenthesis, after which an indented code is written.

 def function_name ( x1 , x2 , x3 , ...):
      code

In JavaScript, the lone contrasts are that we characterize a capacity utilizing the 'work catchphrase 'and encompass the body of the capacity with 'wavy supports'.

function function_name (x1,x2,x3,...)

{

    code
}

Object Oriented Programming(OOP)

OOP is the development of programs in terms of objects that interacts with each other.

Both Python and JavaScript do uphold Object-Oriented programming.

The syntax of defining a class in both Python and JavaScript is almost the same there is a slight difference.

In python a colon is written after the keyword class whereas curlybraces are used in Javascript.

Python

class Rectangle:

    code

JavaScript

class Rectangle

{

    code
}

Constructor and Attributes

A constructor is a member function of a class that executes automatically whenever an object is created.

In Python, a constructor that instates the new example is known as init with two driving and following highlights. This strategy is called consequently when an example of the class is made to introduce it's ascribes. Its boundaries list characterizes the qualities that we need to pass to make the example. This rundown begins with self as the principal boundary.

 class Rectangle:

        def _init _(self , length , width):
            self.length= length
            self.width=width

In JavaScript, a constructor strategy is called constructor and it has a rundown of boundaries as python has.

class Rectangle

{

    constructor(length,width){
        this.length=length;
        this.width=width;

    }
}

NB

In python, we use self to refer to an instance of a class.
i.e


self.attribute= esteem

While in JavaScript we use this to allude to an occurrence of a class.
i.e


this.attribute=value;

Methods In Python and JavaScript.

We characterize strategies with the 'def watchword' trailed by the name of the technique and the boundaries list inside brackets. This boundaries list begins with the self boundary to allude to the occurrence that is calling the technique. After this rundown, we compose a colon (:) and afterward on another line the body of the technique indented.

 class Rectangle:

        def _init _(self , length , width):
            self.length= length
            self.width=width

        def calc_area(self):
             return self.length*width

In javascript the syntax is as shown below.

class Rectangle

{

    constructor(length,width)
    {
        this.length=length;
        this.width=width;
    }

    calcArea()
    {
        return this.length*width;


    }

}

Learning curve

Although these two languages, Python and Javascript, are have got the differences listed above but
In terms of learning and implementing, Python is much easier than JavaScript because its syntax is much easier to understand and also implementing.