In this final part of our application Part Four, we are going to take care of the random IP address generation algorithm. Because we want to allow the user to generate several random IP addresses from the subnet. I've used a while loop while true right here that keeps asking the user if he wants a new IP address from that subnet to be generated after generating the previous one. As long as he answers why for Yes, the code inside the if block will be executed, and those new addresses will be generated. Of course, as we've seen before, to implement such a behavior, we need a continuous statement, as you can see right here, that brings the user back to the top of the while loop at the point where he is asked to input Y for yes or no for No. So after the while true loop and also the input function, asking the user for input We need an IF block.

So if the user enters why, then the code under the if clause gets executed. Otherwise, inside the else clause, the break statement interrupts the while loop and the program is terminated. Now let's focus on the code under the if clause. First of all, notice right here that we have a four loop nested inside another for loop. And each of these loops refers to one of the lists we've seen earlier, namely, BSD IP address and net IP address. So this list right here, and this list right here, let's get back to our four loops nested for loops.

Now let's go ahead and see those lists again by uncommenting. The corresponding print functions in order to have a very clear picture of what we're about to do. So I'm going to uncomment this and this print function save. Let's run the application. So by THON the Network apps subnet calculator, Python three.pi 192 168 dot 10 dot 1255255255 dot zero. Okay, so these are the lists right here.

Okay, so I must have on commented the wrong print function. Yes, I should have uncomment this one right here. Okay, save the file again, let's run the application 192 168 dot 10 dot 1255255255 dot zero. Okay, great. So these two lists right here, these lists contain the octet of the network address and the broadcast address respectively. Now let's talk a bit about the enumerate function that you're seeing right here in the code.

Keep in mind that enumerate returns both the index of one element and the value of that element at the same time. In order to see that let's uncomment the print function inside the First for loop. So I'm going to do this. And I'm going to run the application once again. 192 168 10 dot one. Okay, let's press Y.

So as you can see right here, we got index zero for the first octet in the broadcast address, which is 192, then index one for the second octet, and so on. Good. Now, let's check the same thing using the second print function. So I'm going to comment this print function right here. And I'm going to uncomment the function on the nested for loop, save the file. And now let's run it once again, to see the results.

Hit Yes, this time, this loop being a nested for loop, it will be executed each time the first loop iterates over the broadcast address of that list. So total of four iterations one for each element of the list. That's why we get the network address index value pair four times. Okay, great. Now Let's get back to the code. And let's focus on this piece of code.

So up until this point, we iterated over the elements of both lists. Now let's see the logic behind this part of our application. Inside the nested for loop, we have an IF block nested inside another if block. So as soon as the program iterates over the elements of both lists, and learns their indexes and values, we are inserting some conditions. Now let me explain the logic within this nested if else code block for the elements at index zero in both lists. So for equal indexes, that's the roll of the first if statement right here.

If the values of those elements are equal, this is the role of the second if statement or the nested if statement. Then append that value, as you can see right here to the empty list we created up here called generated IP. By doing this, we are actually appending the network part of the IP address To the list, so that would be the common octet of the network and broadcast addresses. Otherwise, if the octet at a particular index in the first list is different than the octet at the same index in the second list, then the program executes the lines of code indented under the else clause. First of all, let's focus on the code inside the parentheses. So this code right here, I've used the module called random, which is a Python built in module.

And from that module, I've used the RAND int method. What this method does is it generates a random integer between the values given as arguments inclusively. So if you have random dot random of one comma 10. Actually, let's try this right into the Python interpreter. So import random, and let's say we have random dot Rand int of one comma 10. This line of code may generate any number between In one and 10, including the boundary values one and 10.

In our case, we want a random integer to be generated for each octet representing the host part of the IP address. This number cannot be 300, for example, which would be an invalid value for an IP address octet, we must obtain valid octets as well as random IP addresses anywhere in between the network IP address and the broadcast IP address. So inside the subnet, finally, after the random octet has been generated, it should be converted to a string and added to the same list called generated IP. So this is the role of the append method and the str function. We are appending the random octet to this list in order to join the elements of this list into a single IP address. That will actually be the final random address that we need.

And of course, after joining the octet inside this list together, we should print that random IP address to the screen. So this is the join method right here using the.as, a delimiter. Of course, as for any IP address, and finally we have print random IP address is, and we have a string format operator and the IP address itself. So let's uncomment these two print functions right here, in order to see the list of octets. And finally, the random IP address. I'm going to save the file.

And now let's run the application. Once again, 192 168 dot 10 dot 1255255255 dot zero, I'm going to hit y. And indeed, this is the list. And this is the random IP address itself after joining the elements of the list, also, let's generate a couple of other random IP addresses just to prove that this works. So I'm going to hit Y for yes. And this time you can see that another random IP address has been generated dot 10 dot six.

We previously had dot 10 dot 42 only So let's try it once again. And this time we have dot 10 dot 104. And we could do this on and on until we get the number of random IP addresses that we need. Of course going back to the code, the last thing we should do in our application is called the subnet calc function. And now we are ready to do some testing in the next lecture. So I'll see you soon