If you want to automate a specific repetitive task or prevent yourself from writing repetitive code in your programs, using a loop is the best option for that.

Loops are a set of instructions that run repeatedly until a condition is met. Let's learn more about how loops work in Python.

Loops in Python

There are two types of loops built into Python:

• for loops
• while loops

Let's focus on how you can create a while loop in Python and how it works.

What is a while loop in Python?

The general syntax of a while loop in Python looks like this:

while condition:
    execute this code in the loop's body

A while loop will run a piece of code while a condition is True. It will keep executing the desired set of code statements until that condition is no longer True.

A while loop will always first check the condition before running.

If the condition evaluates to True then the loop will run the code within the loop's body.

For example, this loop runs as long as number is less than 10:

number = 0
while number < 10:
    print(f"Number is {number}!")
    number = number + 1

Output:

Number is 0!
Number is 1!
Number is 2!
Number is 3!
Number is 4!
Number is 5!
Number is 6!
Number is 7!
Number is 8!
Number is 9!

Here, the variable number is set to 0 initially.

Before any code is run, Python checks the condition (number < 10). It evaluates to True so the print statement gets executed and Number is 0! is printed to the console.

number is then incremented by 1. The condition is re-evaluated and it is again True, so the whole procedure repeats until number is equal to 9.

This time Number is 9! is printed and number is incremented, but now number is equal to 10 so the condition is no longer met and therefore the loop is terminated.

It's possible that the while loop never runs if it doesn't meet the condition, like in this example:

number = 50
while number < 10 :
    print(f"Number is {number}!")

Since the condition is always False, the instructions in the loop's body don't execute.

Don't create infinite loops

As you saw from the example above, while loops are typically accompanied by a variable whose value changes throughout the duration of the loop. And it ultimately determines when the loop will end.

If you do not add this line, you will create an infinite loop.

number will not be incremented and updated. It will always be set and remain at 0 and therefore the condition number < 10 will be True forever. This means that the loop will continue to loop forever.

# don't run this

number = 0
while number < 10:
    print(f"Number is {number}!")

Output:

Number is 0!
Number is 0!
Number is 0!
Number is 0!
Number is 0!
Number is 0!
Number is 0!
...

It runs infinitely.

It is the same as doing this:

#don't run this
while True:
    print("I am always true")

What if you find yourself in a situation like this?

Press Control C to escape and end the loop.

What is a do while loop?

The general syntax of a do while loop in other programming languages looks something like this:

do {
  loop block statement to be executed;
  }
while(condition);

For example, a do while loop in C looks like this:

#include <stdio.h>

int main(void)
 {
   int i = 10;
   do {
      printf("the value of i: %i\n", i);
      i++;
      }
  while( i < 20 );
 }

What is unique in do while loops is the fact that the code in the loop block will be executed at least one time.

The code in the statement runs one time and then the condition is checked only after the code is executed.

So the code runs once first and then the condition is checked.

If the condition checked evaluates to true, the loop continues.

There are cases where you would want your code to run at least one time, and that is where do while loops come in handy.

For example, when you're writing a program that takes in input from users you may ask for only a positive number. The code will run at least once. If the number the user submits is negative, the loop will keep on running. If it is positive, it will stop.

Python does not have built-in functionality to explicitly create a do while loop like other languages. But it is possible to emulate a do while loop in Python.

How to emulate a do while loop in Python

To create a do while loop in Python, you need to modify the while loop a bit in order to get similar behavior to a do while loop in other languages.

As a refresher so far, a do while loop will run at least once. If the condition is met, then it will run again.

The while loop, on the other hand, doesn't run at least once and may in fact never run. It runs when and only when the condition is met.

So, let's say we have an example where we want a line of code to run at least once.

secret_word = "python"
counter = 0

while True:
    word = input("Enter the secret word: ").lower()
    counter = counter + 1
    if word == secret_word:
        break
    if word != secret_word and counter > 7: 
        break

The code will run at least one time, asking for user input.

It is always guaranteed to run at least once, with True, which otherwise creates an infinite loop.

If the user inputs the correct secret word, the loop is terminated.

If the user enters the wrong secret word more than 7 times, then the loop will be completely exited.

The break statement allows you to control the flow of a while loop and not end up with an infinite loop.

break will immediately terminate the current loop all together and break out of it.

So this is how you create the a similar effect to a do while loop in Python.

The loop always executes at least once. It will continue to loop if a condition is not met and then terminate when a condition is met.

Conclusion

You now know how to create a do while loop in Python.

If you're interested in learning more about Python, you can watch the 12 Python Projects video on freeCodeCamp's YouTube channel. You'll get to build 12 projects and it's geared towards beginners.

freeCodeCamp also has a free Python Certification to help you gain a good understanding and a well rounded overview of the important fundamentals of the language.

You'll also get to build five projects at the end of the course to practice what you've learned.

Thanks for reading and happy learning!

On average I work with JSON data 18 times a week. And I still need to google for specific ways to manipulate them almost every time. What if there was an ultimate guide that could always give you the answer?

In this article, I'll show you the basics of working with object arrays in JavaScript.

If you ever worked with a JSON structure, you've worked with JavaScript objects. Quite literally. JSON stands for JavaScript Object Notation.

Creating an object is as simple as this:

{
  "color": "purple",
  "type": "minivan",
  "registration": new Date('2012-02-03'),
  "capacity": 7
}

This object represents a car. There can be many types and colors of cars, each object then represents a specific car.

Now, most of the time you get data like this from an external service. But sometimes you need to create objects and their arrays manually. Like I did when I was creating this e-shop:

Considering each category list item looks like this in HTML:

I didn't want to have this code repeated 12 times, which would make it unmaintainable.

Creating an array of objects

But let's get back to cars. Let's take a look at this set of cars:

We can represent it as an array this way:

let cars = [
  {
    "color": "purple",
    "type": "minivan",
    "registration": new Date('2017-01-03'),
    "capacity": 7
  },
  {
    "color": "red",
    "type": "station wagon",
    "registration": new Date('2018-03-03'),
    "capacity": 5
  },
  {
    ...
  },
  ...
]

Arrays of objects don't stay the same all the time. We almost always need to manipulate them. So let's take a look at how we can add objects to an already existing array.

Add a new object at the start - Array.unshift

To add an object at the first position, use Array.unshift.

let car = {
  "color": "red",
  "type": "cabrio",
  "registration": new Date('2016-05-02'),
  "capacity": 2
}
cars.unshift(car);

Add a new object at the end - Array.push

To add an object at the last position, use Array.push.

let car = {
 "color": "red",
 "type": "cabrio",
 "registration": new Date('2016-05-02'),
 "capacity": 2
}
cars.push(car);

Add a new object in the middle - Array.splice

To add an object in the middle, use Array.splice. This function is very handy as it can also remove items. Watch out for its parameters:

Array.splice(
  {index where to start},
  {how many items to remove},
  {items to add}
);

So if we want to add the red Volkswagen Cabrio on the fifth position, we'd use:

let car = {
  "color": "red",
  "type": "cabrio",
  "registration": new Date('2016-05-02'),
  "capacity": 2
}
cars.splice(4, 0, car);

Looping through an array of objects

Let me ask you a question here: Why do you want to loop through an array of objects? The reason I'm asking is that the looping is almost never the primary cause of what we want to achieve.

JavaScript provides many functions that can solve your problem without actually implementing the logic in a general cycle. Let's take a look.

Find an object in an array by its values - Array.find

Let's say we want to find a car that is red. We can use the function Array.find.

let car = cars.find(car => car.color === "red");

This function returns the first matching element:

console.log(car);
// output:
// {
//   color: 'red',
//   type: 'station wagon',
//   registration: 'Sat Mar 03 2018 01:00:00 GMT+0100 (GMT+01:00)',
//   capacity: 5
// }

It's also possible to search for multiple values:

let car = cars.find(car => car.color === "red" && car.type === "cabrio");

In that case we'll get the last car in the list.

Get multiple items from an array that match a condition - Array.filter

The Array.find function returns only one object. If we want to get all red cars, we need to use Array.filter.

let redCars = cars.filter(car => car.color === "red");
console.log(redCars);
// output:
// [
//   {
//     color: 'red',
//     type: 'station wagon',
//     registration: 'Sat Mar 03 2018 01:00:00 GMT+0100 (GMT+01:00)',
//     capacity: 5
//   },
//   {
//     color: 'red',
//     type: 'cabrio',
//     registration: 'Sat Mar 03 2012 01:00:00 GMT+0100 (GMT+01:00)',
//     capacity: 2
//   }
// ]

Transform objects of an array - Array.map

This is something we need very often. Transform an array of objects into an array of different objects. That's a job for Array.map. Let's say we want to classify our cars into three groups based on their size.

let sizes = cars.map(car => {
  if (car.capacity <= 3){
    return "small";
  }
  if (car.capacity <= 5){
    return "medium";
  }
  return "large";
});
console.log(sizes);
// output:
// ['large','medium','medium', ..., 'small']

It's also possible to create a new object if we need more values:

let carsProperties = cars.map(car => {
 let properties = {
   "capacity": car.capacity,
   "size": "large"
 };
 if (car.capacity <= 5){
   properties['size'] = "medium";
 }
 if (car.capacity <= 3){
   properties['size'] = "small";
 }
 return properties;
});
console.log(carsProperties);
// output:
// [
//   { capacity: 7, size: 'large' },
//   { capacity: 5, size: 'medium' },
//   { capacity: 5, size: 'medium' },
//   { capacity: 2, size: 'small' },
//   ...
// ]

Add a property to every object of an array - Array.forEach

But what if we want the car size too? In that case we can enhance the object for a new property size. This is a good use-case for the Array.forEach function.

cars.forEach(car => {
 car['size'] = "large";
 if (car.capacity <= 5){
   car['size'] = "medium";
 }
 if (car.capacity <= 3){
   car['size'] = "small";
 }
});

Sort an array by a property - Array.sort

When we're done with transforming the objects, we usually need to sort them one way or another.

Typically, the sorting is based on a value of a property every object has. We can use the Array.sort function, but we need to provide a function that defines the sorting mechanism.

Let's say we want to sort the cars based on their capacity in descending order.

let sortedCars = cars.sort((c1, c2) => (c1.capacity < c2.capacity) ? 1 : (c1.capacity > c2.capacity) ? -1 : 0);
console.log(sortedCars);
// output:
// [
//   {
//     color: 'purple',
//     type: 'minivan',
//     registration: 'Wed Feb 01 2017 00:00:00 GMT+0100 (GMT+01:00)',
//     capacity: 7
//   },
//   {
//     color: 'red',
//     type: 'station wagon',
//     registration: 'Sat Mar 03 2018 01:00:00 GMT+0100 (GMT+01:00)',
//     capacity: 5
//   },
//   ...
// ]

The Array.sort compares two objects and puts the first object in the second place if the result of the sorting function is positive. So you can look at the sorting function as if it was a question: Should the first object be placed in second place?

Make sure to always add the case for zero when the compared value of both objects is the same to avoid unnecessary swaps.

Checking if objects in array fulfill a condition - Array.every, Array.includes

Array.every and Array.some come handy when we just need to check each object for a specific condition.

Do we have a red cabrio in the list of cars? Are all cars capable of transporting at least 4 people? Or more web-centric: Is there a specific product in the shopping cart?

cars.some(car => car.color === "red" && car.type === "cabrio");
// output: true

cars.every(car => car.capacity >= 4);
// output: false

You may remember the function Array.includes which is similar to Array.some, but works only for primitive types.

Summary

In this article, we went through the basic functions that help you create, manipulate, transform, and loop through arrays of objects. They should cover most cases you will stumble upon.

If you have a use-case that requires more advanced functionality, take a look at this detailed guide to arrays or visit the W3 schools reference.

Or get in touch with me and I will prepare another article :-)