In Python, there is no need to use a specific data type for arrays. You can simply use a list with all the attributes of an array.

If you want to create an array that includes both integers and floating-point numbers, you can use Python's array module.

What is an Array?

An array is a unique type of variable that has the capacity to store more than one value at once.

Let's say you have a list of objects like country names. You could store the countries in separate variables as follows:

Country1 = "Germany";

Country2 = "France";

Country3 = "Denmark";

But suppose you wanted to search through all of the countries to discover a certain one. What if you had 200 countries instead of only 3?

The alternative is to store all these values in an array.

Arrays are useful for storing and manipulating multiple values of the same data type. They act like a variable that can hold a collection of values, all of which are the same type. These values are stored together in bordering memory.

Python Array Methods

You can use various built-in Python methods when working with lists and arrays. Below are the methods you can use on arrays and lists in Python.

The Append() method

If you want to add an item to the end of a list, you can utilize the append method.

Example:

fruits = ['apple', 'banana', 'cherry']
fruits.append('orange')
print(fruits)  


# Output: ['apple', 'banana', 'cherry', 'orange']

The append() method is used to add elements to the end of a list. In this case, 'orange' is appended to the fruits list, resulting in the list containing four elements: 'apple', 'banana', 'cherry', and 'orange'.

Here's another example for you:

Let's create an array containing the names of cars:

cars = ["Lexus", "Toyota", "Mercedez"]

You can use the append() method to add a new element to an existing list/array just as seen below.

fruits = ["apple", "banana", "cherry"]
fruits.append("orange")
print(fruits)


# Output: ['apple', 'banana', 'cherry', 'orange']

Output:

["Lexus", "Toyota", "Mercedez", "Honda"]

The Clear() method

The clear() method removes all the elements from the list, just as the name implies.

Example:

Below is an example using the clear() method:

cars = ["Lexus", "Toyota", "Mercedez"]

cars.clear()

print(cars)

Output:

Based on the explanation of the clear() method above, the result of this expression will be [] empty because we have cleared the entire list.

The Copy() method

This function creates and returns an identical copy of the original list.

Example:

fruits = ["apple", "banana", "cherry"]
fruits_copy = fruits.copy()
print(fruits_copy)


# Output: ['apple', 'banana', 'cherry']

In the above example, the copy() method creates a new array called fruits_copy, which is a shallow copy of the fruits array. Modifying the fruits_copy array will not affect the original fruits array.

Here's another example using the copy() method:

cars = ["Lexus", "Toyota", "Mercedez"]


x = cars.copy()


print(x)


# Output of the above using the copy () method will be:


["Lexus", "Toyota", "Mercedez"]

The Count() method

This method returns the number of elements with the specified value.

Example:

fruits = ["apple", "banana", "cherry", "banana"]
count = fruits.count("banana")
print(count)


# Output: 2

The code above creates a list called fruits with four elements: 'apple', 'banana', 'cherry', and another 'banana'. The count() method is then used on the fruits list to count the number of occurrences of the element 'banana'. It returns the count, which in this case is 2, as 'banana' appears twice in the list.

Finally, the count value is printed to the console, resulting in the output: 2.

Here's another example of using the count() method:

# Return the number of times the value "Lexus" appears in the car list.

cars = ["Lexus", "Toyota", "Mercedez", "Lexus"]

x = cars.count("Lexus")

print(x)

Output of this would return int "2" as the result because "Lexus" appears twice in the cars list.

The Extend() method

With this method, you can add the elements of a list (or any iterable) to the end of the current list.

Example:

fruits = ["apple", "banana", "cherry"]
additional_fruits = ["orange", "grape"]
fruits.extend(additional_fruits)
print(fruits)

# Output: ['apple', 'banana', 'cherry', 'orange', 'grape']

In the example above, the extend() method is used to add the elements from the additional_fruits list to the fruits array. The resulting array contains all the elements from both arrays.

Note that the extend() method modifies the original array in place and does not return a new array.

The index() method

This method returns the index of the first element with the specified value.

fruits = ["apple", "banana", "cherry"]
index = fruits.index("banana")

print(index)

# Output: 1

This code above creates a list of fruits containing 'apple', 'banana', and 'cherry'. It then finds the index position of 'banana' in the list and assigns it to the variable 'index'. Finally, it prints the value of 'index', which in this case would be 1.

The insert() method

This array method adds an element at the specified position.

numbers = [1, 2, 3, 5, 6]
numbers.insert(3, 4)
print(numbers)

# Output: [1, 2, 3, 4, 5, 6]

From the code above, we have an array numbers with elements [1, 2, 3, 5, 6]. We want to insert the number 4 at index 3 (which is the fourth position in the array, as Python is 0-indexed). By calling insert(3, 4), we insert the element 4 at the specified index, and the existing elements are shifted to the right to make room for the new element. The resulting array is [1, 2, 3, 4, 5, 6].

The pop() method

This method removes the element at the specified position.

Example:

# To delete an item from an array/list, you can utilize the pop() method.

# Delete the second element of the car array:

cars = ["Lexus", "Toyota", "Mercedez"]

cars.pop(2)

print(cars)

And here's the output:

['Lexus', 'Toyota']

This code above deletes the second element from the 'cars' array using the 'pop()' method and then prints the updated array.

Here's another example using the pop() method:

# To delete an item from an array/list, you can utilize the pop() method.

# Delete the second element of the car array:

cars = ["Lexus", "Toyota", "Mercedez"]

cars.pop(2)

print(cars)

Output:

['Lexus', 'Toyota']

The code deletes the second element from the cars array using the pop() method and then prints the modified array. The resulting array will contain only the first and third elements: ['Lexus', 'Toyota'].

The remove() method

This method removes the first item with the specified value.

Example:

fruits = ["apple", "banana", "cherry"]
fruits.remove("banana")
print(fruits)

# Output Below:

["apple", "cherry"]

The code above creates a list called fruits with three elements: 'apple', 'banana', and 'cherry'. The remove() method is then used to remove the element 'banana' from the list.

After removing 'banana', the updated list is printed using the print() function. The output will be ['apple', 'cherry'], as 'banana' is no longer present in the list.

Here's another example using the remove() method:

cars = ["Lexus", "Toyota", "Mercedez"]

cars.remove("Toyota")

print(cars)

The remove() function may also be used to remove an element from an array, but it should be noted that it only removes the first instance of the specified value from a list.

The reverse() method

This method reverses the order of the list.

Example:

fruits = ["apple", "banana", "cherry"]
fruits.reverse()
print(fruits)


# Output: ['cherry', 'banana', 'apple']

The code above creates a list called fruits with three elements: 'apple', 'banana', and 'cherry'. Then, the reverse() method is called on the fruits list which reverses the order of its elements. Finally, the reversed list is printed using the print() function, resulting in the output ['cherry', 'banana', 'apple']. This means that the original order of the fruits list has been reversed.

The sort() method

This method sorts the list, just as the name implies.

Example:

numbers = [4, 2, 1, 3]

numbers.sort()

print(numbers)

# Output: [1, 2, 3, 4]

The code above creates a list called numbers with the elements [4, 2, 1, 3]. The sort() method is then called on the numbers list, which sorts the elements in ascending order. After sorting, the numbers list becomes [1, 2, 3, 4]. Finally, the sorted list is printed to the console using print(numbers), which outputs [1, 2, 3, 4].

the sort() method in Python sorts the elements of a list in ascending order by default. If you want to sort the list in descending order, you can pass the parameter reverse=True to the sort() method.

Here's an example of how to sort the numbers list in descending order:

numbers = [4, 2, 1, 3]

numbers.sort(reverse=True)

print(numbers)

# Output

[4, 3, 2, 1]

By passing reverse=True as an argument to the sort() method, the list is sorted in descending order.

Conclusion

Hopefully, after reading this article, you should now have a basic understanding of what an array is in Python.

You should also know the basic Python array methods that you'll use to modify an array or a list and how to use them.

Sometimes you might see an ellipsis (...) that appears to indicate that some content or text is hidden. Have you ever wondered how you can code that feature?

In this tutorial, we'll look at how to do multi-line truncations in CSS using JavaScript. Let's get this party started!

What is Text Truncation?

In CSS, text truncation is used to truncate text that overflows its container by hiding the extra content and replacing it with ellipses. This technique is useful for creating more compact and visually appealing layouts in situations where the length of the text may vary, such as in navigation menus, table cells, or headings.

The CSS property you use for text truncation is text-overflow. To enable text truncation, you need to set the text-overflow property to "ellipsis" and the white-space property to nowrap to prevent the text from wrapping to the next line. You may also need to set the overflow property to "hidden" to hide any text that overflows the container.

Let's discuss these properties in more detail now.

CSS Properties to Truncate Text

Different properties in CSS may be used to truncate text. Below are some of the most common CSS properties:

text-overflow : This property specifies how the text content should be displayed when it overflows the element's content area. The text-overflow property can take one of the following values:

• clip: If the text exceeds the element's content area, it is clipped and not shown.
• ellipsis: If the text exceeds the element's content area, it is truncated, and an ellipsis (...) is inserted at the end.
• fade: If the text exceeds the element's content area, it is truncated, and a fade effect is added to the end.

white-space: This property controls how white space characters in text are treated. The white-space attribute has the following possible qualities:

• normal: The browser will break lines of text to fit within the available space.
• nowrap: The browser will not break lines of text, which can cause the text to overflow the element's content area.
• pre: The browser will preserve whitespace characters, which can cause the text to overflow the element's content area.

overflow: This property specifies how the overflowed content should be handled. The overflow property can take one of the following values:

• visible: The overflowed content is visible and not clipped.
• hidden: The overflowed content is hidden and not visible.
• scroll: The overflowed content is visible, and scrollbars are added to enable scrolling.
• auto: The overflowed content is visible and scrollbars are added to the element only if the content overflows.

To truncate text, you can use the text-overflow property in combination with the white-space and overflow properties. For

Dynamic Truncation

You can also implement dynamic truncation using CSS to display text content on a webpage. One common use case for dynamic truncation with CSS is to limit the amount of text displayed in a container while providing a "read more" link or button to allow users to expand the content.

Here's some example HTML and CSS code that implements dynamic CSS in text truncation, with a border around the text to indicate its width:

The HTML code:

<html>
  <body>
    <div class="list">
      <div class="card">
        <h3>First Example</h3>
        <p class="text single-line">
          mollis, ante non euismod ornare, orci diam ornare orci, eu mattis
          tortor lectus at erat. Nam rutrum erat nec euismod lacinia. Curabitur
          et velit ut mauris euismod tempus. Fusce pharetra augue lectus, quis
          maximus quam auctor pellentesque.  
        </p>
      </div>
      <div class="card">
        <h3>Second Example header</h3>
        <p class="text single-line">
          Curabitur pharetra, erat a gravida malesuada, augue mi tincidunt odio,
          quis rhoncus tortor metus ut purus. Nunc lectus quam, tempus sed
          mollis id, feugiat a quam. Donec posuere nulla a lacus interdum
          faucibus ut tincidunt nisi. 
        </p>
      </div>
    </div>
  </body>
</html> <body>
    <div class="list">
        <div class="card">
          <h3>First Example</h3>
          <p class="text single-line">
                  Lorem ipsum dolor sit amet, consectetur adipiscing elit. Nam augue nulla, elementum non erat id, cursus feugiat sem. Vestibulum ante ipsum primis in faucibus orci luctus et ultrices posuere cubilia curae; Nullam velit neque, tincidunt in ipsum vel, accumsan mattis nisi. 
          </p>
        </div>
            <div class="card">
          <h3>Second Example header</h3>
          <p class="text single-line">
            Curabitur pharetra, erat a gravida malesuada, augue mi tincidunt odio, quis rhoncus tortor metus ut purus. Nunc lectus quam, tempus sed mollis id, feugiat a quam. Donec posuere nulla a lacus interdum faucibus ut tincidunt nisi. Curabitur consequat vitae turpis quis lobortis. 
          </p>
        </div>
      </div>

</body>
</html>

Below is the HTML code output without adding the CSS:

Here's the CSS code to truncate the overflowing text:

.list {
  display: flex;
  flex-direction: column;
}

.card {
  border: 1px solid #1948e3;
  border-radius: 8px;
  height: 100px;
  margin: 0 auto;
  padding: 15px 25px;
  width: 890px;
}

.card:not(:last-of-type) {
  margin-bottom: 20px;
}

.text.single-line {
  overflow: hidden;
  text-overflow: ellipsis;
  white-space: nowrap;
}

Below is the image output of the paragraph after linking the CSS code above with it:

Below is a GIF to show the behavior of the text after linking it with CSS to truncate the text dynamically:

How to Create Multi-line Truncated Text

CSS properties effectively truncate a single line of text or multi-line text spanning two lines or fewer. But it is also possible to achieve text truncation for multi-line text using JavaScript.

In the following sections, we will explore two techniques for multi-line text truncation, one using CSS and the other using JavaScript. By examining both approaches, you can decide which technique is best suited to your needs.

How to Use CSS to Truncate Multi-line Text

CSS properties function well for a single line of text and multi-line text that spans more than two lines.

The first step is to specify the height of the box or element. Next, we multiply the line-height by the number of lines we wish to ignore before truncating to get the max-height.

Here’s how it’s done:

<body>
  <h3>Multi-line Text Truncation overflow!</h3>

  <p class="truncate-overflow">
    Lorem ipsum dolor sit, amet consectetur adipisicing elit. In sint facilis
    explicabo voluptatum exercitationem earum. Quibusdam vitae, iusto temporibus
    corrupti tempore distinctio soluta reiciendis. Ab aspernatur facilis autem
    temporibus veniam.
  </p>

  <p class="truncate-overflow">
    Multi-line text truncation is a common design pattern that allows designers to show a limited amount of text on a web page or application, while still giving users the ability to see more if they desire.
  </p>

  <p class="truncate-overflow">
    In CSS, there are several ways to truncate multi-line text, including using the text-overflow property in combination with display, white-space, and overflow.
  </p>
</body>

Below is the image output of the above HTML code:

Now let's set the Overflow to hidden and the max-height to our preferred height, the same as the line-height.

Then we have -webkit-box-orient set to vertical, -webkit-line-clamp, and text-overflow set to ellipsis. We'll also change the display to box:

:root {
  --lh: 1.4rem;
}

html {
  max-width: 22rem;
  margin: 2rem auto;
  line-height: var(--lh);
}

.truncate-overflow {
  --max-lines: 3;
  position: relative;
  max-height: calc(var(--lh) * var(--max-lines));
  overflow: hidden;
  padding-right: 1rem;
}
.truncate-overflow::before {
  position: absolute;
  content: "...";
  bottom: 0;
  right: 0;
}
.truncate-overflow::after {
  content: "";
  position: absolute;
  right: 0;
  width: 1rem;
  height: 1rem;
  background: white;
}

Below is an image showing the multi-line text truncation with pure CSS:

How to Use JavaScript to Truncate Multi-line Text

JavaScript also has the ability to truncate text. Below is an example of how to implement JavaScript to truncate text depending on a certain number of characters.

Let's have a look at how we can do this with JavaScript. To begin, let's define a function named truncate and pass the words to be truncated as parameters. We'll additionally provide a maximum-length parameter.

Here's an example of HTML code for truncating text with JavaScript:

<script src="Truncate.js"></script>
<body>
  <div>
    <h1>Text Truncate Example Header</h1>
    <p id="text">
      Lorem ipsum dolor sit amet, consectetur adipiscing elit. Morbi in sapien
      eu velit eleifend ullamcorper eget vitae nulla. Aenean euismod purus sed
      neque dictum, nec lobortis ante faucibus.
    </p>
    <button onclick="truncateText()">Truncate Text</button>
  </div>
</body>

Below is an image output of pure HTML code before adding the JavaScript function and the CSS border function:

Here's the JavaScript code:

function truncateText() {
  var text = document.getElementById("text").innerHTML;
  var truncated = text.substring(0, 50) + "...";
  document.getElementById("text").innerHTML = truncated;
}

And here's the CSS code:

#text {
  border: 1px solid black;
  padding: 10px;
}

The HTML code in the example contains a paragraph element with the ID "text" that contains some sample text. The truncateText function in the JavaScript code retrieves the text from the paragraph element.

With these modifications, when the "Truncate Text" button is clicked, the text will be truncated to 50 characters and a border will be added to the truncated text. It also inserts an ellipsis at the end.

The function is invoked when the user hits the "Truncate Text" button, and the text in the paragraph element is replaced with the truncated content.

Below is an image output after adding both CSS and JavaScript to the HTML code above:

Below is an illustrative GIF to show the output:

This example demonstrates a fundamental approach to truncating text using JavaScript.

How to Add an Element After the Ellipsis

The Ellipsis (...) is used to represent a text truncation, indicating that some content has been omitted from the display. The text-overflow property is used to specify what happens to the text that overflows the container.

Here's an example with the HTML code below:

<div class="parent-box box">
  <div class="child-box">
    You are learning text truncation with javascript, which is done with these
    three steps
  </div>
</div>

Here's the image output of the HTML code before introducing the ellipsis:

We added the :after pseudo-element to the parent element.box to accomplish this. The nest div is then given the class.child-box and an inline-block display. This allows the .parent-box pseudo-element to appear after the width of the .child-box.

The hidden overflow is triggered if the defined max-width is exceeded. If there is a text-overflow, we can have the ellipsis and the element of the .parent-box.
Below is the CSS code to add an Element after the Ellipsis:

.box {
  margin: 10px;
  padding: 10px;
  border: 1px solid rgb(0, 0, 0);
  width: 200px;
  overflow: hidden;
  text-overflow: ellipsis;
  white-space: nowrap;
  position: relative; /* Add this to make sure the ::after element is positioned relative to the parent */
}

.child-box::after {
  content: "+"; /* Change the content to the desired element */
  position: absolute;
  right: 0;
  bottom: 0;
}

.no-max-width {
  max-width: none;
}

Here's the output after introducing the above code:

Conclusion

We have looked at how to truncate text in CSS using a variety of CSS and JavaScript approaches in this tutorial.

We also looked at how to add an element after the ellipsis, which can be tricky in some circumstances.

For example, temperature measurements are critical for effective data analysis and interpretation in everything from weather forecasting to material research. As a result, having an effective and easy-to-use temperature converter calculator is critical for both professionals and students.

In this tutorial, we'll look at how to create a temperature converter calculator in Python. Python is a popular programming language with a large community and many helpful libraries, making it an excellent choice for creating a temperature converter calculator.

You will learn how to make a powerful and effective temperature conversion calculator that can convert between multiple temperature scales such as Celsius, Fahrenheit, and Kelvin by following the step-by-step directions in this tutorial.

Requirements:

To follow along with this tutorial, you will need to have Python installed on your computer. You can download the latest version of Python from the official website.

We will also be using the Python standard library, which should be included with your Python installation.

How to Build the Temperature Converter Calculator

The first step in creating our temperature converter calculator is to define the temperature scales that we want to convert between.

In this example, we will be converting between Celsius, Fahrenheit, and Kelvin. We will create a dictionary that maps each temperature scale to a unique identifier.

TEMPERATURE_SCALES = {
    'Celsius': 'C',
    'Fahrenheit': 'F',
    'Kelvin': 'K'
}

Next, we will define a function to convert a temperature from one scale to another. This function will take as input the temperature value, the input temperature scale, and the output temperature scale. It will then use the appropriate conversion formula to convert the temperature to the desired scale.

def convert_temperature(value, input_scale, output_scale):
    if input_scale == 'C':
        if output_scale == 'F':
            return value * 1.8 + 32
        elif output_scale == 'K':
            return value + 273.15
        else:
            return value
    elif input_scale == 'F':
        if output_scale == 'C':
            return (value - 32) / 1.8
        elif output_scale == 'K':
            return (value + 459.67) * 5 / 9
        else:
            return value
    elif input_scale == 'K':
        if output_scale == 'C':
            return value - 273.15
        elif output_scale == 'F':
            return value * 9 / 5 - 459.67
        else:
            return value
    else:
        return value

Now that we have our conversion function, we can create the main program. We will use a while loop to repeatedly prompt the user for input until they choose to quit.

For each conversion, we will prompt the user for the input temperature value, the input temperature scale, and the output temperature scale. We will then call our conversion function to convert the temperature and print the result.

while True:
    # Prompt the user for input
    print('Enter the input temperature value:')
    value = float(input())
    print('Enter the input temperature scale (C, F, or K):')
    input_scale = input().upper()
    print('Enter the output temperature scale (C, F, or K):')
    output_scale = input().upper()

    # Convert the temperature and print the result
    result = convert_temperature(value, input_scale, output_scale)
    print(f'{value} {input_scale} = {result} {output_scale}')

    # Prompt the user to continue or quit
    print('Enter q to quit, or any other key to continue:')
    choice = input()
    if choice.lower() == 'q':
        break

When you run the program, you will see the following output:

Enter the input temperature value:

You can then enter the input temperature value, the input temperature scale (C, F, or K), and the output temperature scale (C, F, or K). The program will then convert the temperature and print the result. You can continue to convert temperatures until you choose to quit by entering 'q'.

This is the output of the above code:

Conclusion

In this article, we have demonstrated how to create a temperature converter calculator using Python. With just a few lines of code, we can build a robust and efficient temperature converter that can convert between Celsius, Fahrenheit, and Kelvin.

Oracle, the company that owns Java, claims that Java is used on 3 billion devices worldwide, making it one of the most popular programming languages.

In this article, we will discuss the history of Java, reasons to use Java for backend development, the top tech companies that already use Java for this purpose, and the top Java frameworks for backend development.

We will also explore the benefits and drawbacks of using Java for backend development.

History of the Java Programming Language

Java was launched in 1991 when James Gosling and his team at Sun Microsystems began development on the language.

Soon after, the team shifted its focus to developing the language for the newest specialized market, the World Wide Web.

Java was offered to the public in 1995 for usage in various applications ranging from the internet to computer programming. According to learncodewith.me, Java is one of the top three programming languages in the world for backend development. It's also ranked first among the top ten programming languages for 2022.

Why You Should Use Java for Backend Infrastructure

The following are some benefits of using the Java programming language for backend development.

Scalability and Robustness

Java has a robust type-checking mechanism that makes it durable. The Java virtual machine (JVM) enables dynamic linking and a secure environment, allowing Java to run anywhere.

Java's automatic memory management and disposal collection make it highly scalable and these features help speed up web application development.

Open Source Library

The vast majority of Java libraries are free and open-source, with expert support. The use of such libraries speeds up the back-end programming of web projects dramatically.

There are many Java libraries for various uses, including logging, JSON parsing, unit testing, XML and HTML parsing, messaging, PDF and Excel reading, cryptography, and many others.

Diversity

Java has long been the dominant programming language for developing Web applications, Android applications, and software tools such as Eclipse, IntelliJ IDEA, NetBeans IDE, and others.

Java's use cases have now grown to include data science applications, machine learning applications, and even IoT applications.

Simplicity

Java syntax is relatively simple, easy to develop, learn, maintain, and understand, and the code is easily debuggable.

Java is also less complex than languages such as C and C++ because many of these languages' sophisticated features, such as explicit pointers, storage classes, operator overloading, and many others, have been eliminated from Java.

Security

Java reduces security concerns and dangers by reducing the use of explicit pointers. A pointer is a value that keeps the memory address of another value and can be exploited to gain unwanted memory access. This issue is solved by removing the concept of pointers.

Platform Independency

image from techavidan

Java is platform-independent, which means it's a "Write Once, Run Anywhere" (WORA) language.

The compiled code (the byte code of Java) is platform-independent and can run on any machine, irrespective of the operating system. We can run this code on any machine that supports the Java Virtual Machine (JVM), as shown in the figure above.

Multithreading Support

Java is a multithreaded language, which means that multiple threads can run at the same time.

A thread is a process's smallest unit. Multithreading allows us to maximize CPU use. Multiple threads share the same memory space, increasing the application's efficiency and performance.

Drawbacks of the Java Programming Language

Lack of Backup Facility

Java is primarily concerned with storage and does not prioritize data backup. This is a huge drawback, and it is losing user interest and ratings as a result.

Code Complexity

Java code is extensive, which means it contains many words and long, complex sentences that are hard to read and comprehend. This reduces the code's readability.

Java strives to be more manageable, but it must settle for unnecessarily complex programs and detailed explanations for each thing.

Speed and Performance Level

Java consumes a large amount of memory and is substantially slower than native languages such as C or C++. This is partly because each bit of code must be interpreted into machine-level code. This slow performance is caused by the JVM's additional level of compilation and abstraction.

Memory Capacity

When compared to other languages such as C and C++, Java uses a significant amount of memory. Memory efficiency and system performance may suffer during cleanup execution.

Top Companies That Use Java

To begin with the list, according to statistics based on Codegym, 10,130 companies are said to employ Java in their IT stacks. Not unexpectedly, the United States leads among enterprises that use Java, accounting for more than 60% of Java clients (about 64,000 businesses).

Linkedin: This application is primarily written in Java, with some C++ parts thrown in for good measure. Java is excellent for LinkedIn's search and analytics. More specifically, it addresses scale concerns, allowing the server to function faster while using fewer resources.

Uber: Uber is the next big Java-based firm. The organization works with a large amount of real-time data, tracking drivers and incoming ride requests. As a result, Uber should be able to sift the data and match users swiftly. That's where Java comes in, handling requests and transmitting data as quickly as possible.

Microsoft: Even though Java does not control Windows or anything similar, Microsoft uses it for various purposes. For example, it requires Java to construct its proprietary Edge web browser.

NASA World Wind: NASA built the Word Wind app, which features a realistic 3D virtual globe and can display precise geographical data, largely thanks to Java (the program uses actual images from satellites to develop 3D representations of the planets). It's an open-source program that runs on practically any operating system because it's developed in Java.

Netflix: Netflix, the same as PayPal, primarily uses Java for practically everything. And because Netflix is one of the best-known entertainment platforms in the world, there is a significant demand for Java expertise in this organization.

In addition to the tech titans mentioned earlier, Java is used by Airbnb, Google, eBay, Spotify, TripAdvisor, Intel, Pinterest, Groupon, Slack, Flipkart, and many more. Without a doubt, you can find Java practically anywhere.

Differences Between a Java Backend and a Node.js Backend

Java and Node.js are both popular choices for building server-side applications. But they have some key differences that make each one better suited for different use cases.

In terms of strengths, Java has the advantage of being a statically-typed language, which provides better performance and stability. Java also provides better security features, such as the Java Virtual Machine (JVM), which has memory protection and isolation. Java also has a large number of libraries and tools available, which makes it easier to develop and maintain large-scale applications.

Node.js, on the other hand, has the advantage of being a dynamically-typed language, which makes it easier to learn and more flexible. Node.js is also well-suited for real-time applications, such as chat applications, thanks to its event-driven architecture. Node.js also has a large and active community, which provides a wealth of libraries and tools for various tasks.

In terms of weaknesses, Java can be slower to develop and more complex compared to Node.js, due to its strong typing and verbose syntax. Java also requires more memory compared to Node.js, which can make it less suitable for low-memory devices.

Node.js, on the other hand, has weaker type checking compared to Java, which can lead to unexpected errors. Node.js also has a single-threaded architecture, which means that it is not as well-suited for multi-threaded applications compared to Java.

In conclusion, both Java and Node.js have their own strengths and weaknesses for backend development. Java is well-suited for large-scale and complex applications, while Node.js is well-suited for real-time and scalable applications. The choice between the two ultimately depends on the specific requirements of the project.

Top Java Frameworks for Backend Development

There are various Java backend frameworks, each with its own capabilities and features. Below are a few popular examples:

Spring

The Spring framework is a lightweight Java application framework and an inversion of a control container.

The framework's core functionality can be used by any Java application, although there are enhancements for constructing web applications on top of the Java EE framework.

Hibernate

Hibernate ORM is an object-relational mapping tool written in Java that provides a framework for translating a relational database into an object-oriented domain model.

Play

The Play Framework combines productivity and performance, making it simple to create scalable Java and Scala online applications. Play is developer-friendly, with a "simply hit refresh" workflow and testing support built in.

Because of Play's stateless and non-blocking architecture, applications scale reliably. Play is ideal for current online and mobile apps because it is RESTful by default and includes asset compilers, JSON, and WebSocket support.

Struts

Apache Struts is a free and open-source web application framework used to create Java EE web applications. It uses and improves the Java Servlet API to encourage developers to use a model-view-controller paradigm. Craig McClanahan designed it and presented it to the Apache Nation.

Conclusion

In this article, you learned about the Java programming language's history. You have also learned the key distinctions between Java and Node.js, clearing up any uncertainty.

Finally, you understand what Java is used for, the industries in which it can be found, and some of its distinguishing traits. You can now use it in your own web apps for seamless backend development.

You can quickly watch videos with a few mouse clicks, but downloading videos is difficult. But in a recent upgrade, YouTube now allows you to save videos in its download folder for offline viewing. Still, you are unable to save them locally.

In this tutorial, you will learn how to use Python code to download YouTube videos. As you may know, one of Python's great strengths is its huge number of modules and libraries. We will write the Python script using the popular pytube package.

Prerequisites

Below are the basic requirements to proceed with this tutorial:

• Understanding of the Python Programming language
• You must have Python 3+ installed on your computer
• You must have installed the Python library Pytube
• You should have a Python code editor such as Pycharm, Vscode, and so on.

Pytube Overview and Installation

Pytube is a small, dependency-free Python module for accessing videos from the internet.

The native library is not pytube – you must first install it to be able to use it. When you have pip, installation is simple.

To install Pytube using pip, you will need to open your command prompt CLI as an administrator and enter the following command:

pip install pytube

The pytube library improves video downloads. Build the YouTube module's object by supplying the URL as a parameter. Then, obtain the video's proper extension and resolution. You can change the name of the file at your leisure – otherwise, the original name will be retained.

Now let's get to the main aspect of writing and implementing the code to download our favorite videos from YouTube.

from pytube import YouTube

def Download(link):
    youtubeObject = YouTube(link)
    youtubeObject = youtubeObject.streams.get_highest_resolution()
    try:
        youtubeObject.download()
    except:
        print("An error has occurred")
    print("Download is completed successfully")


link = input("Enter the YouTube video URL: ")
Download(link)

You use the from pytube import YouTube function to import the Python Pytube library before continuing with the other aspects. Then you define the function download link.

The youtubeObject = youtubeObject.streams.get_highest_resolution() command will automatically download the highest resolution available.
Then I implemented the Try and Except to return an error message if the download fails – else it will print out that the download is completed successfully.

The Link function will ask for the preferred YouTube video link to download, then immediately after you hit the enter button, the video downloading will commence.

The Output:

The video I downloaded was successful. You can see the video in the same Python folder where the file you are working on is located. But if you wish, you can then move the video to your preferred storage location. In my case the video name is "Ronaldo celebrates with Antony.mp4."

However, it would be preferable if you had a reliable internet connection.

This library also has numerous sophisticated features, but we have covered all of the major ones. You can learn more about the pytube library by visiting its official well-written documentation.

Conclusion

We have successfully built a YouTube video downloader script of our own in Python. This helps you avoid the stress of looking for an external website or application to get your preferred video to your local storage.

It also saves you from having to expose your data on a third-party website or phishing link – all in the name of getting a video from YouTube to your local storage.

Hopefully after going through this article, you will understand the process required to download videos from YouTube without the need to download an external application or visit any website you don't trust.

So in this tutorial, I'm sharing a few pointers and strategies to help you improve your Python programming skills.

How to Reverse a String in Python

In Python, there is no built-in method for reversing a string. The quickest (and perhaps easiest?) method is to employ a slice that moves backward, -1.

For instance, suppose we have a string "Freecodecamp" that we wish to reverse. Make a slice that goes backward from the end of the string.

In this case, the slice expression [::-1] indicates to begin at the end of the string and terminate at position 0, then move with step -1, negative one, which implies one step backward.

# Create a variable name "a"
a = "Freecodecamp"
# Then you assign freecodecamp to variable 'a'
print("Reverse is", a[::-1])

The below output shows the backward version of the string "freecodecamp":

Reversing a string in Python

How to Print the File Path of Imported Modules

Python offers a very simple method for getting the file paths of an imported module. This is useful if you need to quickly identify a file path while working on a project with several subdirectories, or if you're using scripts or applications that are typically accessible via the command line.

If you're in a similar scenario, you may use the following approach to get your module's precise file path:

import os
import socket

print(os)
print(socket)

That's all. Use this approach to determine the precise location of module files in your code. The module's exact file location should then be printed for you. It will most likely look like this:

output for printing file path

How to Use Enums in Python

An Enum is a collection of symbolic names that are linked to distinct values. They are comparable to global variables, but they have additional helpful capabilities such as repr(), grouping, type-safety, and a few more. As you can see, making an Enum is as easy as building a class that inherits from Enum.

Enum Properties:

• Enums can be shown as a string or as a representation.
• You can use type to determine the type of an Enum ().
• You use the "name" keyword to display the Enum member's name.

class MyName:
    Python, By, Davidking = range(3)

print(MyName.Python)
print(MyName.By)
print(MyName.Davidking)

The output will print out the result according to their number as arranged on the list:

Enum in Python

How to Swap Variable Values in Python

Swapping two variables means switching the values of the variables. In most cases, you do this using the data in memory.

Swapping is as simple as it gets. You can use this step to swap two objects in Python:

a = 1
b = 2

print('Before Swapping')
print(a, b)

a, b = b, a
print('After Swapping')
print(a, b)

The result will return the new interchanged position/number for the two variables "a, b":

swapping in Python Fcc

How to Find the Most Frequent Value in a List in Python

You can use this process to sort out the most repeated value from a list. Imagine a game where numbers were given to people randomly and the group with the most frequent value wins the game. You can use this method to find out the game-winner without the need to count manually.

Now let's see how it goes:

test = [1, 2, 3, 4, 2, 2, 3, 1, 4, 4, 4, 3, 1, 2, 2, 2]
print(max(set(test), key = test.count))

Now the output here will tell us the winner of the game without having to count manually. The output here is "2" when you run the code above.

How to Check the Memory Usage of an Object in Python

With this simple yet powerful Python method, you can calculate how much memory your Python objects consume.

Here is an example below:

import sys
x = 1
print(sys.getsizeof(x))

The result of variable X here is "28".

How to Create a File Server in Python

Servers are pieces of computer software or hardware that handle requests and provide data to clients across a network. There are several sorts of servers, the most popular of which are web servers, database servers, application servers, and transaction servers.

Python's SimpleHTTPServer module is a handy and simple utility that developers may use for a variety of purposes, the most common of which is to serve files from a directory.

It removes the time-consuming procedure of installing and configuring available cross-platform web servers.

Did you want to build a file server in Python? You can accomplish this by using the simple line of code below:

python -m SimpleHTTPServer 
# The default port is 8080

How to Check Your Python Version from IDLE

You might be curious about the Python version you're using. Well, you can check the installed Python version on your PC just by writing a few lines of code:

import sys
print("My Python version Number: {}".format(sys.version))

Output:

My Python version Number: 3.10.7 (tags/v3.10.7:6cc6b13, Sep  5 2022, 14:08:36) [MSC v.1933 64 bit (AMD64)]

Here you go, it will print out the version you are using.

Conclusion

Hopefully, after going through this set of python tips and tricks you find it useful and interesting, Thanks for reading and I wish you good luck in your coding career.

By the end of this tutorial, you should know the basics of how to use files in Python.

File Handling in Python

File handling is an important activity in every web app. The types of activities that you can perform on the opened file are controlled by Access Modes. These describe how the file will be used after it has been opened.

These modes also specify where the file handle should be located within the file. Similar to a pointer, a file handle indicates where data should be read or put into the file.

In Python, there are six methods or access modes, which are:

1. Read Only ('r’): This mode opens the text files for reading only. The start of the file is where the handle is located. It raises the I/O error if the file does not exist. This is the default mode for opening files as well.
2. Read and Write ('r+’): This method opens the file for both reading and writing. The start of the file is where the handle is located. If the file does not exist, an I/O error gets raised.
3. Write Only ('w’): This mode opens the file for writing only. The data in existing files are modified and overwritten. The start of the file is where the handle is located. If the file does not already exist in the folder, a new one gets created.
4. Write and Read ('w+’): This mode opens the file for both reading and writing. The text is overwritten and deleted from an existing file. The start of the file is where the handle is located.
5. Append Only ('a’): This mode allows the file to be opened for writing. If the file doesn't yet exist, a new one gets created. The handle is set at the end of the file. The newly written data will be added at the end, following the previously written data.
6. Append and Read (‘a+’): Using this method, you can read and write in the file. If the file doesn't already exist, one gets created. The handle is set at the end of the file. The newly written text will be added at the end, following the previously written data.

Below is the code required to create, write to, and read text files using the Python file handling methods or access modes.

How to Create Files in Python

In Python, you use the open() function with one of the following options – "x" or "w" – to create a new file:

• "x" – Create: this command will create a new file if and only if there is no file already in existence with that name or else it will return an error.

Example of creating a file in Python using the "x" command:

#creating a text file with the command function "x"

f = open("myfile.txt", "x")

We've now created a new empty text file! But if you retry the code above – for example, if you try to create a new file with the same name as you used above (if you want to reuse the filename above) you will get an error notifying you that the file already exists. It'll look like the image below:

• "w" – Write: this command will create a new text file whether or not there is a file in the memory with the new specified name. It does not return an error if it finds an existing file with the same name – instead it will overwrite the existing file.

Example of how to create a file with the "w" command:

#creating a text file with the command function "w"

f = open("myfile.txt", "w")

#This "w" command can also be used create a new file but unlike the the "x" command the "w" command will overwrite any existing file found with the same file name.

With the code above, whether the file exists or the file doesn't exist in the memory, you can still go ahead and use that code. Just keep in mind that it will overwrite the file if it finds an existing file with the same name.

How to Write to a File in Python

There are two methods of writing to a file in Python, which are:

The write() method:

This function inserts the string into the text file on a single line.

Based on the file we have created above, the below line of code will insert the string into the created text file, which is "myfile.txt.”

file.write("Hello There\n")

The writelines() method:

This function inserts multiple strings at the same time. A list of string elements is created, and each string is then added to the text file.

Using the previously created file above, the below line of code will insert the string into the created text file, which is "myfile.txt.”

f.writelines(["Hello World ", "You are welcome to Fcc\n"])

Example:

#This program shows how to write data in a text file.

file = open("myfile.txt","w")
L = ["This is Lagos \n","This is Python \n","This is Fcc \n"]

# i assigned ["This is Lagos \n","This is Python \n","This is Fcc \n"] to #variable L, you can use any letter or word of your choice.
# Variable are containers in which values can be stored.
# The \n is placed to indicate the end of the line.

file.write("Hello There \n")
file.writelines(L)
file.close()

# Use the close() to change file access modes

How to Read From a Text File in Python

There are three methods of reading data from a text file in Python. They are:

The read() method:

This function returns the bytes read as a string. If no n is specified, it then reads the entire file.

Example:

f = open("myfiles.txt", "r")
#('r’) opens the text files for reading only
print(f.read())
#The "f.read" prints out the data in the text file in the shell when run.

The readline() method:

This function reads a line from a file and returns it as a string. It reads at most n bytes for the specified n. But even if n is greater than the length of the line, it does not read more than one line.

f = open("myfiles.txt", "r")
print(f.readline())

The readlines() method:

This function reads all of the lines and returns them as string elements in a list, one for each line.

You can read the first two lines by calling readline() twice, reading the first two lines of the file:

f = open("myfiles.txt", "r")
print(f.readline())
print(f.readline())

How to Close a Text File in Python

It is good practice to always close the file when you are done with it.

Example of closing a text file:

This function closes the text file when you are done modifying it:

f = open("myfiles.txt", "r")
print(f.readline())
f.close()

The close() function at the end of the code tells Python that well, I am done with this section of either creating or reading – it is just like saying End.

Example:

The program below shows more examples of ways to read and write data in a text file. Each line of code has comments to help you understand what's going on:

# Program to show various ways to read and
# write data in a text file.

file = open("myfile.txt","w")
L = ["This is Lagos \n","This is Python \n","This is Fcc \n"]

#i assigned ["This is Lagos \n","This is Python \n","This is Fcc \n"]
#to variable L

#The \n is placed to indicate End of Line

file.write("Hello There \n")
file.writelines(L)
file.close()
# use the close() to change file access modes



file = open("myfile.txt","r+") 
print("Output of the Read function is ")
print(file.read())
print()

# The seek(n) takes the file handle to the nth
# byte from the start.
file.seek(0) 

print( "The output of the Readline function is ")
print(file.readline()) 
print()

file.seek(0)

# To show difference between read and readline

print("Output of Read(12) function is ") 
print(file.read(12))
print()

file.seek(0)

print("Output of Readline(8) function is ") 
print(file.readline(8))

file.seek(0)
# readlines function
print("Output of Readlines function is ") 
print(file.readlines()) 
print()
file.close()

This is the output of the above code when run in the shell. I assigned "This is Lagos", "This is Python", and "This is Fcc" to "L" and then asked it to print using the ''file.read'' function.

The code above shows that the "readline()" function is returning the letter based on the number specified to it, while the "readlines()" function is returning every string assigned to "L" including the \n. That is, the "readlines()" function will print out all data in the file.

Conclusion

Hopefully, after going through this tutorial, you should understand what file handling is in Python. We also learned the modes/methods required to create, write, read, and close() a text file using some basic examples from Python.

Thanks for reading!

What is Code Refactoring?

Refactoring means organizing your code without modifying its original functionality. Refactoring is the process of making small changes or adjustments to your code without affecting or changing how the code functions while in use.

Why Do You Need to Refactor Your Code?

It Helps Improve Your Code/Program

Refactoring helps you improve the design of your software because developing applications is a difficult task. As you add additional functions, the relevance of the program may be affected. Then, abstractions are no longer as pure as they once were.

You can improve things by refactoring your code regularly to demonstrate a better understanding of the program or code you're working with.

It Gives You a Better Understanding of the Code

If you refactor properly, your code will be more easily understandable afterwards. You can also make the code easier to understand by improving the design.

It is common knowledge that developers read code far more frequently than they write it. As a result, it's in your best interest to keep things as simple as possible, which considerably improves maintainability. Also, people who read it in the future will be grateful.

Refactoring Broadens Your Knowledge

Finally, refactoring is a method of active learning. Even if you didn't write the code, refactoring it gives you a better grasp of what it does.

How Refactoring Helps Your Team

Refactoring is a common activity for software development teams. If done correctly, refactoring your code makes it easier for your team members to understand your code and the changes you've made.

The refactoring stage is often difficult for teams to include in their process. But refactoring, in my opinion, is an essential component of working on any process. Adding comments for me entails leaving the code in a better state than when I found it.

Whatever you do, avoid creating a separation between technical value and business value (creating the feature). You can do this by keeping the code understandable.

Refactoring Best Practices – with Python Examples

If you want to get the most benefit from restructuring your code, you should keep the following in mind:

• Refactor only tested code. Without tests, refactoring code is, to put it bluntly, gambling. If you don't have tests that verify that the before and after are equivalent, you can't be certain you didn't break the code. No matter how disciplined you are, eventually, you'll introduce bugs.
• Minimize refactoring. The modification is riskier the more drastic it is. Divide it into several more compact portions. You get flexibility and mitigation.
• Take little, gradual steps. Check to see if everything is working after making a small code change.
• Observe the guidelines. Don't begin adding functionality while refactoring is still being done. Refactoring has no impact on the system's output. Before moving on to the next challenge, complete this one.

Below is an example of code refactoring using the Define function in Python to find the force (F) required to move an object of mass (m) with an acceleration (a) given by the formula “F = m x a”.

Because we are performing a repeated task, it's a good idea to use a function instead of using only the conditional statement. So when we need to in the future, we just have to call the function out for usage.

Code Before Refactoring:

Notice how the two blocks look nearly identical. What if we’re calculating the “Work done” by a person or machine? Most likely, we’d copy and paste the while loop, changing the variable name and input prompt. Now let's use a function to refactor this.

Code After Refactoring:

Now that our code is simpler to understand, we can start to save some lines of code. What's more, in the future, we'll be able to effortlessly insert our function into another script by just calling out the function, saving us time.

Here are some other tips to keep in mind while refactoring your Python code:

Use List Comprehension Instead of a For Loop

One of the most well-known Python constructs is list comprehension. Compared to several basic for loops, list comprehension provides a cleaner, quicker solution.

The code will run more quickly, existing data won't be altered, and list comprehensions are simpler to understand at a glance once you become used to them.

Below is a simple expression of using list comprehension instead of a For Loop:

Initial code:

In the above example, we loop through a list of integers (numbers) to see if we should enter each one into the odd numbers list.

Refactored code:

In the above-refactored code, the list comprehension is an assignment into the odd numbers. Then we iterate over the "numbers" and set the return (the first item). Then, we can include an if-statement to filter.

Use Def Functions for Repetitive Tasks

Defining functions for repetitive tasks is the first and perhaps most significant refactoring we can perform.

Although functions provide many advantages, from the standpoint of refactoring, we will shorten our code and increase readability. In addition, you only have to update the job once, in the declaration of the function (the example given below).

Initial code:

Refactored code:

Use Ternary Operators Instead of if-else Statements:

You can use an easy if-statement like this to find if an input integer is an "even" or "odd" number instead of an if-else statement:

The ternary operator is used in the code above to determine if an integer is even or odd.

msg will be assigned Even if the condition (to_check% 2 == 0) is true. msg will also be assign Odd if the condition (to check% 2 == 0) is not true.

Note: you can't use the ternary operator to replace any code that uses an if-else expression. For example, if-else statements involving more than two cases.

Use the Enumerate Function Instead of Range():

Python for loops can be complicated, especially if you are coming from another programming language.

Initially, you might have thought to make an index variable and use it to loop through your list. As a result, people often find and utilize the range() method. But it's not a best practice to use this method. Below is an example:

Code Before Refactoring:

Using the index on the initial list makes it more difficult to understand and encourages poor habits like changing original values. Particularly in complex nested data structures.

Additionally, we need to manually change the index's values into "counting numbers."

Code After Refactoring:

The enumerate() method returns the current counter value and each item in the iterable and requires two arguments: the iterable and the initial count value.

Note: It is a typical error to order the temporary count variable first in the for loop and the initial count value second in the function call.

Conclusion

Hopefully, you now understand what code refactoring is along with the importance and reasons for refactoring your code.

Based on the simple Python code above, you should understand that refactoring does not necessarily mean your code needs to be shorter after refactoring – but just somehow simpler and more understandable.