Python: Control Statements


In this article, we take a look at the major control statements in Python. Primary we look at the control statements if-elif-else, for,while and control exit statement break. We list sample code for each of these and use in-line comments to explain what the code line does. Note that we declare the same functions in a class to adhere to object-oriented semantics. You can easily copy/paste the code in your Python code.

if-elif-else statement
?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
class DemoClass:
    def IfThenElse(self):
        # Using integer
        inp = int(input("Enter a number: "))
        if inp < 0:
            print("Number is negative")
        elif inp == 0: #Else-if
            print("Number is 0")
        else:
            print("Number is positive")
 
        # Using a string input
        inp = input("Enter your name: ")
        if inp == "Albert":
            print("Are you Albert Einstein ?")
        elif inp == "Blaise":  # Else-if
            print("Are you Blaise Pascal ?")
        else:
            print("You are nobody !")
 
 
dc = DemoClass()
dc.IfThenElse()
The output for the above code is:
?
1
2
3
4
5
Sum is :3
Enter a number: 12
Number is positive
Enter your name: Chaitanya
You are nobody !

for loop

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
class DemoClass:
    def ForLoop(self):
        # Print values from 0 to 5
        for value in range(6):
            print(value)
 
        # Print values from 1 to 5
        for value in range(1,6):
                print(value)
 
        # Print values from 1 to 5, step of 2
        for value in range(1, 6, 2):
                print(value)
 
        # Print values from 6 to 2
        for value in range(6, 1, -1):
                print(value)
 
        # Print all values in an array
        # equivalent to foreach
        values=[1,2,3,4,5,6,7]
        for value in values:
                print(value)
 
 
dc = DemoClass()
dc.ForLoop()
The output for the above code is:
?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
0
1
2
3
4
5
1
2
3
4
5
1
3
5
6
5
4
3
2
1
2
3
4
5
6
7

while loop

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
class DemoClass:
    def WhileLoop(self):
        # Print values from 0 to 5
        x = 0
        while x < 6:
            print(x)
            x += 1
 
        # Print values from 1 to 5, step of 2
        x = 1
        while x < 6:
            print(x)
            x += 2
 
        # Print values from 6 to 2
        x = 6
        while x > 1:
            print(x)
            x -= 1
 
        # Print all values in an array
        # equivalent to foreach
        values=[1, 2, 3, 4, 5, 6, 7]
        x = 0
        while x <= 6:
            print(x, ":", values[x])
            x += 1
 
 
dc = DemoClass()
dc.WhileLoop()
The output for the above code is:
?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
0
1
2
3
4
5
1
3
5
6
5
4
3
2
0 : 1
1 : 2
2 : 3
3 : 4
4 : 5
5 : 6
6 : 7

break statement

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
class DemoClass:
    def Break(self):
        # Print values from 0 to 5
        x = 0
        while True:
            print(x)
            x += 1
            if x > 5:
                # exit while
                break
 
        # Print values from 1 to 5, step of 2
        x = 1
        while True:
            print(x)
            x += 2
            if x > 5:
                # exit while
                break;
 
        # Print values from 6 to 2
        x = 6
        while True:
            print(x)
            x -= 1
            if x <= 1:
                # exit while
                break;
 
        # Print all values in an array
        # equivalent to foreach
        values=[1, 2, 3, 4, 5, 6, 7]
        x = 0
        while True:
            print(x, ":", values[x])
            x += 1
            if x > 6:
                # exit while
                break
 
 
dc = DemoClass()
dc.Break()
The output for the above code is:
?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
0
1
2
3
4
5
1
3
5
6
5
4
3
2
0 : 1
1 : 2
2 : 3
3 : 4
4 : 5
5 : 6
6 : 7

Comments

Post a Comment

Popular posts from this blog

Part I: Backpropagation mechanics for a Convolutional Neural Network

Image
In another article, we explained the basic mechanism of how a Convolutional Neural Network (CNN) works. In this article we explain the mechanics backpropagation w.r.t to a CNN and derive it value. We use the same simple CNN as used int he previous article, except to make it more simple we remove the ReLu layer. In part-II of this article we derive the backpropagation in the same CNN with the addition of a ReLu layer. The CNN we use is given below: In this simple CNN, there is one 4x4 input matrix, one 2x2 filter matrix (also known as kernel), a single convolution layer with 1 unit, a single pooling layer (which applied the MaxPool function) and a single fully connected (FC) layer. The elements of the filter matrix are equivalent to the unit weights in a standard NN and will be updated during the backpropagation phase. Assuming a stride of 2 with no padding, the size of the convolution layer is determined by the following equation: $$ N={(W - F + 2.P)\over S} + 1 $$ He...
Read more

Introducing Convolution Neural Networks with a simple architecture

Image
Convolution Neural Networks (CNNs) are different from standard Neural Networks (NNs) as their input is 2-dimensional vs. 1-dimensional in a standard neural network. While the underlying principles between CNNs and NNs are same, CNNs do introduce some new concepts. In this article, we take a look at how CNNs operate using a very simple CNN architecture, given below. In this simple CNN, there is one 4x4 input matrix, one 2x2 filter matrix (also known as kernel ), a single convolution layer with 1 unit, 1 Rectified Linear Unit (ReLu) layer with one unit, a single pooling layer and a single fully connected (FC) layer. The elements of the filter matrix are equivalent to the unit weights in a standard NN and are updated during the backpropagation phase. Real-life CNNs are significantly more complex than this with several repeating layers of convolutional, ReLu and pooling layers forming a true deep learning network. All the matrix dimensions are also magnitudes higher to represent hig...
Read more

Python: Sockets Programming - Non-blocking Client

Image
Sockets are an operation system construct allowing Inter-Process Communication (IPC) over a network. Sockets is how you are able to browse the internet, watch movies or download files from your computer. In a previous article we built a sockets client using blocking calls. In this article, we modify the code of the blocking socket client to make the data receive and send non-blocking. The socket mode for blocking/non-blocking can be set using the setblocking(value) or settimeout(value) functions of the socket class. Another important function is select which is a blocking/non-blocking (depending on mode) and is used to determine if the socket has data to read. Without select if we try to read data and there is none, we will get an exception which will have to be handled. Using select is a more cleaner way (compared to a try-except block) of doing non-blocking calls so that exceptions are used only for capturing genuine errors. We also need a while loop to execute any non...
Read more