Greeting learners! Welcome to the new tutorial on Python, where we are going to discuss the loops. In the previous lecture, our focus was on the primary introduction of the loops in Python. If you are from a programming background, you must know that there is a little bit of difference between the loops in Python and those in other programming languages. At the end of the previous lecture, we saw the details of the basic differences and examined why we consider Python better than other languages when considering loops. In the current lecture, our focus is only on the while loop, and you will get to know its importance soon when we discuss the detail of this loop. But before this, have a look at the list of the major concepts:
What are the loops?
Why do we use the while loop in Python?
What are some major points that must be known about the while loop in Python?
Can we use the loops while designing the games?
What is the concept of statements in Python?
How do break statements work in Python?
What do you know about the continue statement in Python?
What does the else statement do in Python when we use it with the while loop?
All of these are important interview questions and we will find the answer to each and every concept in detail with the example. We have been working with the Jupyter Notebook and therefore, we are again using it for the practical implementation of the concepts of the current lecture. So let’s move towards the first concept.
While loop is one of the most common loops in programming languages and if we talk about Python, loops have fundamental importance and while loop is the favorite of many programmers. No one can get excellence in programming in Python without knowing the detail of the loops in it. The reason why we are learning it so deeply is, there is a bit of difference between Python loops and other programming languages. We discussed it in the previous lecture. There are different reasons behind this statement, and some of them are explained next:
As all the loops do, the while loop repeats itself until a certain condition is satisfied. There is no restriction on the data type in the loop, which means, no matter if you have sequences, strings, integers, or other data types, you can use the while loop anywhere. This gives the programmer the independence to use it in a versatile way by using their creativity. Moreover, keep in mind the condition where the programmer wants to get input from the user after a certain condition is met in the code. In such cases, a while loop is perfect to use, and the restriction can be applied to the input as well.
The idea of the condition is so smooth in the while loop that it becomes interesting to use the sequences in the while loop. In some cases, when the length of the sequence is not known, programmers can use the sequence in the while loop to get the required result. In this way, the compiler keeps iterating the sequence until a certain condition is met.
Have you ever noticed the condition of a game where the sequence of certain objects keeps on moving in a specific sequence? This happens when the loops are used with special planning, and the while loop is one of those loops that provide the perfect results according to the needs of the program. In the simulations where a certain condition is to be fulfilled, the need for the while loop is always felt.
In addition, when the need to fulfil a certain condition is felt, a loop can be used, and the compiler uses the condition again and again until the requirements are met; once the mission is completed, the game is then over. This is the very basic idea that how programmers use while looping in gaming, there are many innovations every year where programmers use the loops in a different way to present interesting results. All the discussion can be proved with the help of the example in the jupyter notebook:
#initializing the while loop with the true condition
while True:
#providing the first condition
try:
#using the integers as the condition
number = int(input("Enter the age of your character: "))
#if the condition is satisfied, the program is terminated
break
#if the condition is not true, throw the error
except ValueError:
#printing the error message
print("The input is not correct, enter only the integers")
Once you have seen the working of the code, you might be thinking, "What happens at the backend?" This example is chosen here to tell you that not all conditions of the loops use a comparison between two things only. We can use the boolean conditions as well to get the required output. If you have seen the simple examples of the while loops, then you must be wondering about the output of this program. You can see that the compiler first gives an error when the input does not meet the requirements of the program.
If the user does not give the expected data type for the program, the compiler goes out of the loop and ignores the break statement. In the second part of the program, the compiler goes to the except value and prints the error message that tells the details of the expected input. In this way, the user understands the requirements in detail, and the program does not end, but the iteration is continued until a certain result is obtained.
In the while loop, there is the ability to use statements of various types, one of which you have just seen. Yet, for the convenience of the learners, we are discussing all the categories in detail. Each of the types has its own example in the Jupyter notebook. To open this, have a look at the steps given next:
In your Windows search bar, go and search for "Jupyter Notebook.”
Wait until it opens a new tab in your browser.
Once the tab is opened, go to the dialogue box and open a new Python project.
It will open a new tab with the cells where you can write your code.
In the while loop, the break statement is used many times. As the name suggests, the break statement breaks the iteration, and the compiler stops executing the program as soon as it passes through the break statement. No matter if the body of the code still has to be executed, if the break statement appears in the code, the compiler stops working. Therefore, programmers use the break statement when they have more than one case and just want to execute the one that suits the condition. There are certain benefits to this statement, and one of these is, it gives the programmer all the long codes at once. Here is an example of a break statement in a while loop:”
#Initializing the variable
a = 4
#Starting a while loop
while a <= 12:
#Printing the required output that we want on the screen
print(a, ":I am a Programmer of Python")
#Using the if loop to provide the condition to the compiler for break statement
if a == 9:
break
#iteration
a += 1
It may seem that the code has some unusual things in it such as the starting point is from 4 instead of 1. This is the way to give you the concept that the starting point is not always zero. It totally depends on the choice of the programmer according to the requirements of the program. Once the variable is declared, the while loop is started, where the maximum number of iterations is shown. Right after declaring the condition, the results are printed.
For the convenience of the reader, I have shown the number of the iteration so that one may understand the whole scenario. Here, to use the break statement, I have shown you the “if” loop. In this way, the compiler understands that whenever the iteration number is 9, it has to stop and jump to the next line instead of completing the iteration. Therefore, after the 9th iteration, the compiler is not showing us any results.
Another thing to notice is, the value of “a” is 4 at the start, but after every iteration, the compiler checks for the value when it is at the last line, and then it sees that the value of “a” is now one number greater, and therefore, the next iteration starts.
If you have understood the previous case, then this one is like a piece of cake because we can say that the working of the continuous statement is somehow opposite to the break statement.
#Initializing the variable
a = 0
#Starting a while loop
while a <= 12:
a += 1
#Using the if loop to provide the condition to the compiler for the continue statement
if a == 3:
continue
#Printing the required output that we want on the screen
print(a,"I am using the continue statement")
The other pieces of code are the same, but you can see there is a bit of difference in the position of some lines. If you have observed this, then you are on point. The iteration is done in the body of the while loop, and right after this, we are using the “if” condition. In the output, observe that the third number of iterations is missing, and this is because we told the compiler to jump whenever the iteration is at the third position. Once the iteration is ignored, the print operation gives us the output on the screen, where our value of the variable and the message on the screen are printed.
The third and last statement of today is the else statement, and this is quite similar to the cases given above. The else statement has the power to show the result once the condition is no longer true. It means that it can be the ending message that we want to print until the condition is satisfied. As a result, we get two blocks of the code at once that can be printed using the same code.
#Initializing the variable
a = 0
#Starting a while loop
while a <= 12:
#Printing the required output that we want on the screen
print(a,"I am using the continue statement")
#iteration
a +=1
#Using the else statement to tell the user that the condition is satisfied
else:
print("The condition is satisfied")
Here, you can see we are getting a continuous stream of the output where every number of the variable is being used. It is because there were no distractions for the compiler in the code within the while loop. Once we have used it to show that all the iterations are done, the compiler then jumps to the else statement, which tells us the final words of the code.
In the end, we can say that today we have learned a lot about the statements used with the while loop in Python, and with the help of examples, the concept is not completely clear. The focus was on the while loop, but using the example of the statements, we understood how we could get the perfect result by merging the concepts of loops and statements in Python. From the introduction to the ending, the discussion was clear about the loops, and we took care of the minor details as well to know best about the while loop. It was an informative lecture, and in the next lecture, we have to know more about loops in Python, so stay tuned with us and be happy with the practice.
Greetings Learners! Welcome to the new lecture on Python. Today we are moving towards an interesting and important concept. If you have come from a programming background, then you must know about the workings of loops. To make the repetition of the same sequence, we use loops. We are familiar with the sequences in detail as we have learned them in the previous lectures and have received the concept in the recent lecture. If you want to be a programmer, then you can not move forward without a solid base of loops; therefore, in this lecture, we will learn the concept of loops from scratch and then go on to a deep understanding of each loop in the next episodes. So have a look at the concepts that you will learn today.
What are the loops?
How do we understand the concept of loops from scratch?
What are some conditions of the loops that we have to understand before programming in loops?
What are the two basic types of loops in Python?
Discuss the syntax and types of loops.
What is the speciality of the while loop?
Why do we prefer the for loop when dealing with for loops?
What are the major differences that make Python better at looping than other types of programming languages?
Each of these is an important interview question, and will we explore the answers of every question mentioned above. In this lecture, the use of Jupyter notebook is not much but for the practicle implementations, this lecture is very important so let us start finding the answers of each question that we have just read now.
In programming languages, loops are the repetition of the same concept, again and again, to get the required output according to the requirements of the programmer. In other programming languages, there are many types of loops, and programmers use them in different ways. Usually, it has been observed that the programmer uses the same kind of loop most of the time that he finds useful or has a good grasp on the concept of a particular type of loop. Loops are defined as:
"Loops are a fundamental control structure in programming that allows you to execute a set of instructions repeatedly until a certain condition is met."
These are extremely useful to execute the conditions and calculations. The working of loops may be different, and the difference in the syntax is an important thing to be noticed, but keep in mind that the output of the loops is almost the same. No matter which type of loop the programmer uses, the output remains the same, just as at the backend, the working and the logic are the same.
When you are going to learn the loops, many people ignore the first step, which is to understand how the loops work at the backend of the code. We are not going into details about how the compiler executes the instruction, but just the steps that have to be followed by the compiler when the user runs the loop. Here are three basic steps:
Checking for the condition created by the programmer. The user always gives the condition at the start of the loop so that the compiler may understand whether the given loop is possible to execute or not. One must keep in mind that the compiler works with the general truths and facts of the real world. It means that if the programmer, say, tells the compiler that 2 is more significant than 10,000, the compiler will reject the condition.
Making the condition is the most important part of the loop for the programmer, and this is the only step where, if you have a strong base in the concept, the programming will become easy for you. This is the only step that will surely run in the loop no matter what condition the programmer applies. It is usually a single line of code, but it is crucial.
Once the condition is satisfied, the body of the code is executed. This is the main step where you will see if you are successful in the loop or not. Once the condition is met and the outcome is true, the compiler enters the body of the loop specified by the programmer and gives the output. Most of the time, the programmer wishes that the condition becomes true, so the remaining code gets the attention of the compiler.
The whole processing is done in the body, and the compiler can give more than one true condition according to the type of condition and other requirements.
It is true that programmers created unusual and amazing products, but there is a limitation that the fact is never ignored. The programmers use the facts in a better way by using their creativity, which results in perfect outputs.
It is obvious that many times, the condition is turned false, and then the compiler simply ignores the body and jumps out of the code. This will only happen if the condition is not satisfied, and this step is not connected with the one that we have just discussed. The detail of each of the steps can be understood by observing the flowchart of the loops given next.
In other programming languages, such as C++ and C#, there are many types of loops. However, in Python, there are primarily two types of loops, each of which has subtypes. In this lecture, you will understand the basic introduction to both of these, and after that, we will move towards the deep concepts and examples of these loops. So, at the most basic level, we can see that there are two types of loops in Python:
While loop
For loop
An introduction to both of them is given next.
The while loop starts with the keyword "while” and then the condition is written so that the compiler can check the condition and then execute the statements written after it accordingly. We introduce the while loop as:
“In programming, the while loop is one of the fundamental types of the loops in which the condition and the statement are the necessary parts of the syntax”
The condition is checked at the start of each iteration, and if it is still true, the loop executes, and this cycle continues until the condition is found to be true. The syntax of a while loop is given next:
while condition
statement(s)
As you can see, the condition is always given first, and the number of statements may vary according to the complexity of the program.
If the concept is taken to a deeper level, we will see that while a loop is a simple type of looping in Python, it has further subtypes, and the names of these are
Infinite loop
Else statement
Single statement while loop
The details and examples of each of them will be discussed in the next lecture.
The for loop is the basic type of looping, and usually, I find it more convenient to use it. Iterations are usually used with the sequence, where the elements of the sequence are repeated again and again. To control the number of iterations, the programmer sets a condition with the “for” keyword, where the compiler always checks the condition and decides whether it has to enter the body or not. Just like the while loop, it can also have more than one statement, and the control is totally in the hands of the programmer.
For iterator in sequence:
statement(s)
Here, you have to understand some concepts:
“For” is the keyword that initiates the loop and tells the compiler to work according to the information fed into the backend.
An iterator can be thought of just like the variable name and the programmer may call it anything according to his choice. Let us say, if it is a, then he will call it in the statement with the same name.
“In” keywords specify that the name of the iterator is now ended and the compiler is now entering into the sequence.
The sequence may be of any type no matter if it is a tuple, array, or list. The good thing about for loop is, it is associated with the sequences and according to the requirement, the programmers can access each and every member of the sequence without making much effort.
Statements may be one or more and it is important that every word of the sequence is correct so that the compiler will execute the instruction and then move towards the for keyword to check the condition again.
From the beginning, we have been saying that Python is simpler than other languages. Moreover, there are other characteristics that make it unique and better. As we are studying the loops so I have made a little comparison between the loops of Python with other programming languages.
Sr# |
Name of the Loop |
Python |
Other Programming Languages |
1 |
For loop |
In Python, the for loop is more versatile because it gives the independence to use any data type whether it is numeric of the string, list, or tuple |
The other programming languages deal with the for loop in just a number of way. It means only the integers are allowed to feed into the for loop of other programming languages. |
2 |
Range function in for loop |
The range function is used in collaboration with the for loop. In Python, it is more concise and dealing with the range function in Python is easier than in other languages, |
In other programming languages, the range function is less concise. The programmers can also use the same function in other languages as well, but dealing with this function is more difficult than in Python. |
3 |
While loop |
The while loop in Python is almost the same as the other languages, but the syntax is different. |
In other programming languages, the while loop works the same as the Python as at the backend, the conditions and workings are the same. |
4 |
Break loop |
Only syntax is different |
Only syntax is different |
5 |
Identation |
It is an important point about Python that makes it unique among others. The identifier is mandatory at some points in Python loops, but in some areas, the unnecessary indentation causes the error. |
The spaces and indentations in other programming languages do not result in any change in the output of the compiler. |
Hence, by using these points, we can conclude that, like every programming language, Python also has many features that make it unique. The loops are more specific and more interesting in Python than in other programming languages, but we have less variety in the loops in Python.
The range function and other functions that have been mentioned above will be discussed with you in detail in the next episode of this lecture. Till then, let us revise the concepts that we have discussed. The concept of loops is important in Python,n and there are only two major types of loops that we have also introduced. The subtypes of these loops also exist. The working of the loops is easy in Python, and we have seen that not all loops have the same syntax, but the differing syntax is important as it differentiates the languages just like other syntaxes. There are three basic steps that are followed by the loops and while constructing the loops, these steps must be cleared in your mind. This was all for today, and in the next episode, you will see the practical implementations of the loops in Python one after the other. Then, try to practice these concepts and keep learning.
Hi learners! Welcome to the next episode of learning the arrays using string data. We have been working with the arrays and in the previous lecture, we saw the interesting characteristics of the string arrays. In the present lecture, our target is to get knowledge about the built-in functions and we will take the strings in the array so that we may know about both of them together. String arrays are used in many officials uses and therefore, we want to use the built-in functions that every Python programmer must know. Here is the list of the concepts that will be polished in this lecture:
What are the built-in methods?
How do you differentiate between methods and functions in programming?
Give different examples to understand different built-in methods to be used in the same code.
How do Jupyet notebook use the copy(), clear(), Insert (), Index(), reverse(), range(), and sort() function in Python on the string array?
How do these functions are related to the working of simple string messages?
For the convenience of the students, we will refresh some important concepts in our mind side by side and whenever required, we will provide the necessary details about the working of the particular method. All these methods have been introduced in Python for a better user experience. One must notice that the same work is also done in other programming languages but Python gives us an uncomplicated way to use them.
Programming is a vast subject and if programmers start making short programs again and again when required, the programming process becomes boring and time taking. For this, the programming languages have built-in methods and functions to be used by simply mentioning them in a specific syntax. Normally, people seem confused between these two because the working and syntax of both of these look alike. So, let's discuss some minor differences between these two.
Function |
Method |
A function is a piece of code that can be reused. It can operate on input data (i.e. arguments), and it can also return data by having a return type. |
A method is associated with the objects with which it is being used. |
It is independent. |
It depends upon the object’s name and requires a reference. |
It is related to the procedural or functional programming language. |
It is related the object-oriented programming concepts. |
The data passes explicitly or at the external level. |
The data in the method is passed internally. |
The working of both of these is similar as the programmer has to input the required data and both of these, after their specific operations, provide the required output as expected.
There are certain methods for the arrays and related concepts that are defined by the Python programming language, but to understand them, we are using the arrays with the string values in them. The method makes the coding easy to use and without knowing them, it is not possible to get the perfect result for a complex task. This will be clear with the help of examples of each of them. A list of such methods is given next:
clear()
copy()
extend()
count()
insert()
index()
Reverse()
Sort()
Here, we want to compare these functions with some of those that are discussed before in this series. So, let’s move towards the first example:
If you are interested in programming, you must know to copy the code from one place to another so that you may test it more accurately and produce the better one by using your concepts. By the same token, another method that is important is clear() which is used to clear the memory area where the array is being stored. In this way, the programmer gets the empty space. For convenience, we are using these two in a single code:
#initializing the array containing the name of programming languages
languages=["C++", "C#", "MATLAB", "ASP.NET", "Flutter"]
print("The original array= " ,languages)
#copying the contents and printing the same results
Languages=languages.copy()
print("The copied array = " ,Languages)
#clear the whole array and printing the results
languages.clear()
print("The clear array= ", languages)
Here, it is important to notice the difference between the clear() and remove(). The clear() causes the empty locations in the array no matter what the size of an array is whereas, in the remove method, the whole array was removed and the compiler throws the error about the existence of that particular array. In other words, the compiler, after the clear() gives you the chance to add the new data of your own choice and you can think that the container of the element is empty but still, we have that container and can fill the data according to our will.
The next methods that we are going to discuss are fun to perform. In the previous lecture, we saw the append method, and this time the same task will be performed with the help of another method called extend(). As the name suggests, this function extends the length of the array by adding another array or extra item to it. The modification of the array is an important feature of Python, and practically, it seems like a blessing in some cases.
The other method that will you see in the code is the count(). It counts the frequency of the mentioned item in the data type, and in our case, we are using it to compare the frequency of the “flutter” before and after the extended array. The element may be any, and the programmer simply has to input it into the method to get the frequency. In programs with a large amount of data where the array or list has 1000+ or even more items, the count() method is a blessing.
#initializing the array containing the name of programming languages
languages=["C++", "C#", "MATLAB", "ASP.NET", "Flutter"]
print("The original array= ",languages)
result=languages.count("Flutter")
print("Numbers of an element before extending =",result)
#extending the array of string
arrayToBeExtend=["java", "javascript", "Flutter"]
languages.extend(arrayToBeExtend)
print("The extended array= ",languages)
result=languages.count("Flutter")
print("Numbers of element before extending =",result)
The next methods to be discussed are the insert and index methods in Python, and we are expecting that you understand the working of these methods. As in the previous cases, the name exactly matches the working name of the method.
#Decalring the array with strings
myStationary=["Notebook", "Pencil", "Erasor", "Pointer", "Papers", "Duster"]
print("Stationaries before insertion= ", myStationary)
#Getting the index of Erasor before insertion
a=myStationary.index("Erasor")
print("Index of Erasor" ,a)
#inserting the new eleemnt at index 2
myStationary.insert(2,"Sharpener")
print("Stationaries after insertion= ", myStationary)
#Getting the index of Erasor before insertion
a=myStationary.index("Erasor")
print("Index of Erasor" ,a)
In the program given above, we have seen that the list of stationary contained the specific numbers of the elements, out of which, the index of the eraser was 2 at first, but after the addition of the new element, the index function tells us the 3 index number.
Now, we are moving towards the situation where we will play with our array. It is interesting to notice that we can retrieve the data in different ways from a single array. Let’s say, the programmer wants results in which the order of the elements in an array is reversed. No matter what the length of the array is, the reverse() method creates the mirror image of the array and represents it. This is important in the field of image processing, where we can invert the images in a simple way.
On the other side, the range function gives us the elements in a specific length of the array according to our needs. We have been using this in the previous examples in this course, but this time, we are specifying the range() method. It is a professional way to do so. The logic behind this is not compulsory to understand; therefore, to make things simple, we are not going into detail. Have a look at the code where we are using both of these methods.
#Declaring the array
myDishes=["chow mien", "sandwiches", "rice", "butter puffs","pizza","meat balls", "rolls", "momos", "patties", "chicken", "coffee cake", "wings"]
print("\bThe array before reversing= ", myDishes)
#Reversing the whole array using the reverse method.
myDishes.reverse()
print("\bThe array after reversing= ", myDishes)
#Using the range method to get the elements
print("\bThe element from 3rd to 8th position are myDishes", myDishes[3:8])
Here, the interesting thing is, just like we used the same method in the previous lecture when we were using the same procedure on the simple string, this time, we have used it on the whole array of the string, and the outcomes are perfect. The programmer can easily get the part of the array they only want and perform different operations on that certain list.
Moreover, the reverse function is also useful in many places, as we have discussed before. The transformation of the array is not just limited to the strings, and in this way, the numbers, when used in the array, can be inverted in their prepositions and useful results can be obtained.
We believe that you are from a programming background, and if you are from a C++ background, then you must have experience with the sorting of an array. We define the sorting process as:
"The sorting of the data is defined as the technique to rearrange the elements in a particular order or manner according to the needs of the data."
Hence, as you can see, there are different ways of sorting, but here, we are using the sorting method that arranges the elements of the string array in alphabetical order. This type of sorting follows the ascending order of the alphabet, and as an example of the reverse method, we will use the sorted array in reverse to get the new array with the descending order of the string array.
#Declaring the array
myDishes=["chow mien", "sandwiches", "rice", "butter puffs", "pizza",
"meat balls", "rolls", "momos", "patties", "chicken", "coffee cake", "wings"]
print("\bThe array before sorting= ", myDishes)
#sorting the whole array using the sort method.
myDishes.sort()
print("\bThe array after sorting= ", myDishes)
#Reversing the whole array using the reverse method to get the array in descending order
myDishes.reverse()
print("\bThe array after sorting= ", myDishes)
Hence, it is a perfect way to understand how we can use the different methods together, (in this case, the reverse method) in the same code to get the desired output. Sorting is an important concept, and in programming languages such as C and C++, sorting is done by long codes, but with the help of this uncomplicated method, the programmers can get the desired output easily in just one step.
Consequently, it was a lecture full of practical examples of the methods in Python, and we have seen many daily life problems that can be arranged in a better manner using the built-in methods. We made the pair of methods into single programs so that we could ignore the repetitions of the same data again and again. Moreover, it provided us with a better chance to understand the professional use of the methods in real-life problems. We hope you learned a lot. Stay with us for more learning.
Hola students! Welcome to the new Python tutorial, where we are learning about OOP. We all know why OOP is important in programming. In the previous lecture, a detailed overview of classes and objects was discussed. We are moving towards the next step of learning where our focus will be on inheritance. Yet, programming also contains inheritance. We have all read about inheritance in real life and are aware of the concepts surrounding it. This time, we will discuss these concepts according to the workings of the classes and related entities. The concept of inheritance is the same in both scenarios, and with the help of interesting examples, the practical implementation of inheritance will be shown to you, but first of all, it would be interesting to know about the main headings that will be shared in detail with you later.
How do you introduce the inheritance in OOP and how do you compare it with the biological inheritance?
What are the basic types of classes that are used in inheritance?
Give some examples of parent and child classes.
How do you explain __init__() function with inheritance?
What do you know about the self keyword?
How to override the parent class in inheritance?
Inheritance is the fundamental concept in OOP, and with the help of Python, the programmers can easily get the required outputs with minimum effort. Keep in mind, OOP is applicable because of its feature of reusability of the code in the perfect way. This helps to curtail the redundancy while working on the development projects. There are different ways of recycling the code in Python, and inheritance is one of the most prominent ways to do so. As in biological inheritance, where the characteristics of the parents are transferred from parents to children, so is it with inheritance in object-oriented programming. The whole concept is about the relationship between different classes and this is important to learn for the large and complex projects of Python.
We have discussed in the previous lectures that different classes can be used at the same time in the same code, and this is the time to utilize that concept. When there is more than one class, it is important to make connections between these classes. Inheritance is a relationship between different types of classes, and this is the basis of the concept of inheritance. The following are the main classes used in inheritance:
Parent class
Child class
The parent class is also known as the base class, and it has the main characteristics that can be inherited or copied by the other classes. Any class can be the parent class, and therefore, there is no special syntax for it. The way to form the simple class is considered the parent class. So, we can think in our mind that all classes are parent classes until they are derived from other classes. Here is an example of a parent class.
Let us take an example from the real world so that you may understand it well. We all know about bank accounts. If we consider the bank account as a parent class, then the types of the bank accounts such as business accounts, saving accounts, etc have many attributes that the “bank account” class may have. So we can consider the savings and business account as the child class so whenever we declare them, we do not have to write all the attributes of other types of bank accounts.
#creating the parent class
class Fish:
#defining the attributes
def __init__(self, firstName="ozzy", LastName="king"):
self.firstName = first_name
self.LastName = last_name
#printing the class
print("Parent class= " , Fish)
In this code, we have just made a simple class with some attributes and considered it the parent class. As you can see, we can make more objects of this class and use it in different ways, but for now, we are not moving forward because the concept here is clear and one that we want to discuss.
As you can guess, the child class is the one that is derived from the parent class and has the same attributes as the parent class. It is a subclass and has a slightly different syntax than its parent class. Let’s say you are talking about bears, All bears can walk, run, eat, and sleep. So, these attributes remain the same, and the parent class, in this case, is "bear,” whereas, the polar bear and brown bear are the subclasses. The same is true for all the animals that have the different kinds of the speicies in them because of the same attributes but have many subclasses. The following code will be a little bit confusing, but the discussion will clarify the concept:
#creating a new class with the name penguin so the animal bird specie is used
class Penguin:
#declaring the attribute and method of the parent class
name = ""
def swim(self):
print("I love swimming")
# a child class that inherits the message from a parent
class tag(Penguin):
# new method in a subclass
def display(self):
# access name attribute of superclass using self
print("My name is ", self.name)
# creating an object of the subclass
pengName = tag()
#Using the superclass attribute and method
pengName.name = "tag"
pengName.swim()
# calling the subclass method created above
pengName.display()
In the beginning, a parent class is declared with the name "Penguin.” This class has two things declared in it. First of all, it tells us that the “name” is in the form of a string. The second thing is the attribute of swimming. This also gives us the string message that the tag can swim. We have written it here just to show that messages from the child and parent can both be used in the output.
In the next step, a child class is introduced in which the particular penguin is declared to have the name “tag”.
Now, let us use the parent class and get the attribute of the name from it. In this way, the child gets the name "tag." Another thing that happened here is, that a new method was formed to explain swimming.
In the end, a built-in method display() is used to display the name of the penguin with a string message that was shown before.
Keep in mind, the display method is not limited to the inheritance only but can be used with most of the entities of the Python.
When dealing with the codes of inheritance, there are different concepts that must be kept in mind so that you may use them with the inheritance, and once the programmers have a grip on it, it becomes easy and comfortable to use inheritance in multiple ways. At this level, it is important to understand the following methods and constructors, and you will notice some of them have already been used in our codes of inheritance. Yet here, we are discussing it in detail so that you may use it in the practice and get the perfect results according to your requirement.
Programming is an interesting field, and when you deal with a hundred lines of code, sometimes, when the programmer does not want to use a specific function for some reason ( when you simply declare the function but there is no need to execute it but other code must be run), then to avoid the errors, the “pass” keyword is used to do so. We can define this keyword as:
"A pass keyword is a simple type of keyword that is used to tell the compiler that the line above this keyword has had no usage till now, so go to the next line during execution."
Sometimes the coders are confused between the pass keyword and the comment, but the difference is that the comment is not part of the code but is the explanation to the user. The pass keyword, on the other hand, simply causes the compiler to jump to the line above it, which may be a function that does not yet have an implementation. The syntax of this keyword is to simply type “pass” right after the line to be skipped.
The reason why we are discussing this keyword here is, this helps a lot in inheritance. If there are many subclasses and the programmer simply wants to ignore one line to check whether my other classes are working or not, they use the “pass” keyword in such cases and it seems to be very interesting.
In the code given above, we are simply placing the pass keyword after the declaration of subclass and the compiler will jump on it and is not able to use it in the methods given in the next lines.
#creating a new class with the name penguin so the animal bird specie is used
class Penguin:
#declaring the attribute and method of the parent class
name = ""
def swim(self):
print("I love swimming")
# a child class that inherits the message from a parent
class tag(Penguin):
#using the pass keyword to jump from the line above
pass
# new method in a subclass
def display(self):
# access name attribute of superclass using self
print("My name is ", self.name)
# creating an object of the subclass
pengName = tag()
#Using the superclass attribute and method
pengName.name = "tag"
pengName.swim()
# calling the subclass method created above
pengName.display()
You can see only the parent class is used here, and the child class is jumped. The code is not able to be executed well because of this jump condition.
Since we are using the concepts of inheritance, have you noticed the usage of __init()? If yes then you must be wondering what is it. This is the constructor of Python and it is used to initialize the data member. That is required when the object of the class is created. At the time of the creation of the object, this function contains the collection of instructions or statements that it contains.
In the previous lectures, we also used another keyword to be noticed, which is the “self” keyword. In simple words, we can say that when we are using the concept of classes, the “self” keyword is used to access the attributes and methods of the class. In some other programming languages, the @ is used to refer to the instant attribute.
Another method that is used in Python, especially with the inheritance concepts, is the overriding method. Till now, we have said that the child class gets the attributes from the parent class, but what if the programmer wants to introduce an attribute with the same name but different features in the child class? For this, we use the overriding method, which is introduced with the statement given next:
"In inheritance, the overriding method allows the child class to have the implementation of the specific method that is already declared in the parent class."
It is important to keep the flow of the code in mind while using the overriding method because incorrect overriding can cause errors or redundancy. Moreover, attributes and classes can both be overridden using this method.
In this lecture, we have learned many simple and smart concepts to deal with inheritance and have learned a lot about them. At the start, we saw the basic definition of inheritance in OOP and compared it with biological inheritance. After that, we have seen what is the child class and parent class. Some important terms about te inheritance was also discussed that were different kind of constructors and methods that we useful in their functioning. In the next lecture, we will talk more about inheritance so stay with us and happy coding.
In the realm of PCB manufacturing, the Gerber file format plays an important role in the design and production processes. Understanding and inspecting these files are crucial to ensuring the accuracy and quality of the printed circuit board (PCB). JLCPCB is a leading PCB fabrication and assembly service provider. Fortunately, it offers an exceptional online tool. It is called the JLCPCB Online Gerber Viewer. It simplifies and enhances the inspection of PCB layouts. In this article, we will discuss the significance of Gerber files. We will explore the reasons for inspection. We will also showcase the powerful functionalities of JLCPCB's Online Gerber Viewer.
A Gerber file, named after the famous Gerber Scientific Instruments, is a standard file format used in the sector of printed circuit board (PCB) manufacturing. It serves as a crucial bridge between the design stage and the physical realization of a PCB. Essentially, a Gerber file is a collection of instructions and data that communicates the precise specifications and details of the PCB design to the manufacturing equipment.
In more technical terms, a Gerber file is generated from the PCB design software and contains a series of commands that describe each layer of the PCB. These commands include information about the placement of copper traces, solder masks, silkscreen markings, drill holes, and other crucial elements that contribute to the final PCB layout. Each layer is represented as a separate Gerber file, allowing manufacturers to accurately interpret and translate the design into a physical PCB.
The Gerber file format has been widely adopted as an industry standard due to its versatility and compatibility with various PCB manufacturing processes and equipment. It provides a concise and standardized representation of the design, enabling seamless communication and collaboration between design engineers and manufacturers.
One of the key advantages of the Gerber file format is its flexibility in accommodating different PCB layer configurations. Whether a PCB design requires single-sided, double-sided, or multi-layer boards, the Gerber file format can adapt to convey the necessary information. Each layer is defined within its respective Gerber file, allowing for clear differentiation and precise control over the manufacturing process.
Furthermore, Gerber files incorporate not only the geometric layout of the PCB but also important manufacturing details. This includes parameters like trace widths, pad sizes, drill hole dimensions, and material specifications, ensuring that the manufacturing equipment performs the necessary operations accurately and consistently.
In summary, a Gerber file is a standardized file format that encapsulates the critical information required to produce a PCB. It serves as a vital communication medium between the PCB design software and the manufacturing equipment. By conveying precise instructions and specifications, Gerber files enable manufacturers to bring PCB designs to life with the utmost accuracy and fidelity.
By analyzing the Gerber files, manufacturers can identify potential manufacturing issues, such as inadequate spacing between components, unachievable trace widths, or insufficient clearances. This helps in optimizing the design for efficient and cost-effective manufacturing. Addressing DFM concerns at the early stages of the design process saves time, reduces manufacturing risks, and streamlines the production timeline.
Detecting errors early in the manufacturing process saves time and resources. Inspecting Gerber files helps identify errors such as missing or overlapping features, incorrect layer assignments, or mismatches in the solder mask and silk screen layers. With the assistance of an advanced online viewer like JLCPCB's, design engineers can quickly spot these errors and rectify them before initiating the manufacturing process, minimizing rework and production delays.
Gerber files act as a common language between designers, manufacturers, and assemblers. Inspecting the files ensures clear communication and effective collaboration, reducing misunderstandings and streamlining the entire production cycle. With the availability of the Online Gerber Viewer, stakeholders can easily share and discuss design iterations, enabling smoother collaboration and efficient decision-making.
JLCPCB's Online Gerber Viewer is a user-friendly and feature-rich tool that simplifies the inspection process of Gerber files. Let's explore some of its notable features:
The viewer boasts an intuitive and easy-to-navigate interface, making it accessible to both beginners and experienced users. The clean layout allows for effortless file upload and exploration. Users can quickly familiarize themselves with the tool, eliminating the need for extensive training or technical expertise. There is a clear-cut set of instructions for ordering.
Below is how the interface looks like. You have to open an account. Then you can login and start uploading your gerber files. You can login anytime to see your upload history.
JLCPCB's Online Gerber Viewer supports a wide range of file formats, including Gerber (RS-274X), Excellon drill files, and even ZIP archives containing multiple Gerber layers. This versatility ensures compatibility with various PCB design software and simplifies the viewing process. Users can confidently upload their Gerber files without worrying about format limitations.
After uploading the zip folder, it can detect the number of layers.
Take a look at the image below. Here the Online Gerber Viewer detected a 2-layered board.
Similarly, in case of this design, the same tool detected 4 layers.
All uploads are secure and confidential.
The viewer enables users to selectively display individual PCB layers or combinations of layers, making it easier to analyze specific components, copper traces, solder masks, silk screens, and other essential elements. This feature provides a comprehensive view of the PCB, allowing users to examine the design from different perspectives and assess its integrity.
You can analyze your PCB layer by layer.
This is when all the layers are visible:
Then you can select the Top layer only:
And this is the bottom layer:
There are other parts of the PCB on the left side of the console. Such as-Top silk, Top solder mask, Top paste mask etc. You can check and uncheck them to view. It makes your observation much more convenient.
The viewer offers zooming capabilities and measurement tools, empowering users to examine intricate details, measure distances accurately, and ensure precise component placements and dimensions. The ability to zoom in and out helps users identify minute details, ensuring that every aspect of the design is thoroughly inspected.
In the image below, we can see the zoom option.
As soon as you upload your gerber files, the Online Gerber Viewer gives you an analysis result. It is done within the shortest possible time.
The following figure shows how an analysis result looks like. You can see pretty much everything. Number of layers, trace width, drill size and lots more. If there is an error in your design, you will see that too. The result shows warnings in yellow.
In addition to 2D views, JLCPCB's Online Gerber Viewer also provides an optional 3D visualization feature. This immersive experience facilitates a better understanding of the PCB's physical appearance, component heights, and spatial relationships. Users can rotate, pan, and zoom in the 3D view to gain a comprehensive understanding of the PCB's three-dimensional structure.
Free or paid |
Free |
Accuracy |
100% |
Online checking |
Available |
Maximum supported size of zip or rar |
20MB |
Layered view |
Available |
Quick transfer facility to JLCPCB factory |
Available |
Measurement tools |
Available |
DFM error detection |
Available |
3D visualization |
Available |
Comprehensive file format support |
Available |
Changing view, toggling units |
Possible |
Zooming, moving,alignment |
Possible |
The JLCPCB Online Gerber Viewer is an invaluable tool that simplifies the inspection and verification of Gerber files, ensuring the accuracy and quality of PCB layouts. By utilizing this user-friendly and feature-rich tool, design engineers, manufacturers, and assemblers can effectively identify errors, optimize designs for manufacturability, and streamline collaboration. The power of JLCPCB's Online Gerber Viewer enhances the efficiency of the PCB manufacturing process, ultimately leading to higher-quality products and faster time-to-market.
With its comprehensive file format support, advanced visualization features, and collaborative capabilities, JLCPCB's Online Gerber Viewer revolutionizes the way PCB layouts are inspected and analyzed. The user-friendly interface and intuitive navigation make it accessible to users of all levels of expertise, eliminating the need for extensive training or technical proficiency. The ability to selectively display and visualize individual PCB layers or combinations of layers provides a comprehensive view of the design, allowing for a thorough assessment of the PCB's integrity.
The zooming and measurement tools offered by the viewer enable users to examine intricate details, ensuring precise component placements and dimensions. The cross-sectional views and optional 3D visualization feature provide an in-depth understanding of the PCB's internal structure, aiding in the identification of potential issues and improving overall manufacturing quality.
By inspecting Gerber files with the JLCPCB Online Gerber Viewer, design engineers can verify the accuracy of their designs, address design for manufacturability (DFM) concerns, and detect errors early in the manufacturing process. This results in optimized designs, reduced manufacturing risks, and improved overall product quality.
In conclusion, the JLCPCB Online Gerber Viewer empowers users to conduct comprehensive inspections of PCB layouts, ensuring the successful realization of design intent. Its intuitive interface, extensive feature set, and collaborative capabilities make it an indispensable tool for anyone involved in the PCB manufacturing process. By harnessing the power of the JLCPCB Online Gerber Viewer, designers and manufacturers can achieve greater efficiency, accuracy, and collaboration, ultimately leading to superior PCBs and accelerated time-to-market for their products.
Artificial intelligence plays a crucial role in commerce by providing personalized recommendations based on previous searches and online behavior. With AI, businesses can optimize products, plan inventory, and improve logistics, which leads to reduced operating costs and increased margins. Whether you aim to scale personalized experiences, delight customers, or create new revenue streams, building an AI solution is essential. While priorities may differ among business owners, AI remains integral to implementing a variety of solutions. In this article, we discuss how AI experts can help develop and grow businesses.
Artificial intelligence solutions offer pre-built or customizable options to tackle specific use cases and overcome business challenges. These solutions enable increased efficiency and growth, provide new methods of operation, and drive transformative innovation. They do so at three times the speed of traditional product development, making them a game-changing asset for any organization. Furthermore, while each solution is already optimized for a particular industry and function, it can be easily personalized to address the unique hurdles of individual clients.
Companies can deploy an AI bot to swiftly automate customer conversations with staff via live chat. Such tools allow them to enhance customer service and alleviate agent overload by automating interactions throughout the entire customer journey. If you are seeking to collaborate with an AI solution provider with a focus on building AI-based chatbots, look no further. Discover more here to aid you in making an informed decision. Chatbots facilitate task automation based on client intent, operating 24/7.
Such cloud-based solutions offer an effortless and streamlined invoicing experience for sellers and buyers alike. With an easy-to-navigate invoice generator, users can create professional invoices with ease and improve their cashflow. Using such tools, you can stay organized and enhance efficiency due to the intuitive step-by-step process.
Internet-of-Things and AI operate on the concept of transmitting real-time information and physical data into the cloud using advanced technology. This stored data can then be processed for various purposes at the application level, including monitoring, alarms, and predictive analytics. Additionally, the integration of machine learning, the usage of ERP or CRM systems, and the utilization of IoT-generated data in blockchain projects are becoming increasingly prevalent. With faster, event-based processes and improved transparency, such solutions have numerous use cases for customers seeking greater efficiency.
AI-development teams consist of highly qualified professionals with extensive programming experience and proficiency in multiple computer languages. These professionals hold BA degrees in fields such as mathematics, data science, statistics, and computer science, which equips them with the necessary skills to excel in building AI solutions. The process for creating these solutions involves defining future goals, recommending necessary tools, as well as devising budgets and timelines for the project. Following this, teams collect data, develop and train algorithms, and ultimately deliver the finished product.
The challenge of developing artificial intelligence expertise is significant due to the high demand for skilled practitioners and the limited availability of qualified individuals. This is largely due to leading tech companies monopolizing the most talented engineers at salaries that many organizations cannot compete with. Successful AI professionals utilize a variety of technologies, such as Python, Django, Oracle, JS, React, and more.
Companies have two options: forming an in-house AI development team or outsourcing to a software development team or consultant with proven AI expertise. Artificial Intelligence encompasses a diverse range of technologies, frameworks, and tools. To effectively solve your business problems, it is crucial to have a proficient external engineering team comprising experienced data scientists and data engineers.
For businesses lacking in-house AI expertise, assembling the required skill set and identifying suitable candidates can be daunting. Thus, engaging an AI solution provider who can supply tech experts or delivery managers to guide you on team composition and recruitment could prove invaluable.
To properly analyze data, it is essential to first collect, organize, and process it. Artificial intelligence heavily relies on large amounts of data, therefore it is crucial to have experienced engineers who are skilled in working with both structured and unstructured data. Additionally, they must be capable of constructing a secure data platform and have a proficient understanding of Hadoop, Pig, Spark, R, Hive, and other technologies.
The experts in question employ machine learning libraries and implement ML solutions for practical use. Moreover, they ensure the reliability and expandability of data science coding.
They are an indispensable component of an AI group. Through their expertise in data manipulation, they craft sophisticated models, scrutinize and analyze data, and get valuable insights using state-of-the-art mining procedures. With their exceptional abilities, they can tackle complex business issues and provide practical solutions.
Numerous AI initiatives involve Natural Language Processing, hence requiring the expertise of NLP specialists. NLP functions as a mediator between human communication and machine interpretation, enabling computers to comprehend and translate human language.
The role of an NLP engineer entails utilizing NLP techniques to convert natural language data into utilizable features for classification algorithms. To excel in this position, specialists must possess exceptional proficiencies in statistical analysis, machine learning methodologies, and text representation techniques.
They excel in image recognition by linking each image to a specific metric, rather than matching metrics with one another. Through computer vision, they create models of objects and environments, providing innovative solutions for medical image analysis and identification tasks.
AI projects require the expertise of a variety of professionals across a range of disciplines. From hiring data scientists to voice recognition specialists, assembling an experienced team is essential for the successful development and deployment of any AI project. With the right combination of talent, businesses can enjoy the benefits that artificial intelligence has to offer. Having the right AI team in place is essential for businesses that want to maximize the potential of artificial intelligence. By understanding the different roles required and sourcing the right talent, they can ensure that their project is a success.
Targeting customers and niche demographics online continues to grow in relevance as more companies adopt telecommuting practices. For this purpose, mass emailing is superior to less extensive forms of advertising in terms of both obtaining prospects and reaching the intended customer base. Amid the growth of social networking sites and other promotional channels, email marketing efforts stay at the forefront of the industry.
Using mass emailing, businesses may find valuable and potential customers for their products and services. Promoting both products and services with the help of such a service increases the likelihood of generating leads and improving ROI.
To help our readers find the easiest options for this, we have compiled a list of easy ways to send a mass email in Gmail below.
Google Mail's BCC feature is a fantastic way to streamline your communication and make sure the proper individuals receive important notifications. The amount of time spent forwarding individual emails to several people reduces and the process is streamlined.
Follow the guideline below on how to do mass email in gmail easily.
Simply access the Google inbox from a computer and choose the Compose button to launch the message composition box.
Create another message addressing it to the initial receiver by typing their full email handle into the For box.
When sending to a large group of people, divide their mailing addresses via punctuation, spaces, or using the 'Enter' button.
You may fill in more people to this BCC group by using the Bcc icon in the header information.
When you use this option, an additional space labeled BCC may display.
Fill up the box with the e-mail address for every anonymous receiver. It's time to write up the email and send it.
An effective method to save energy when sending emails to a large group of individuals who all need unique content is to utilize a mail merge. This is a useful tool to do mass email in Gmail with personalized contact information pre-filled via an integrated database.
Among its many handy functions is the ability to bring in all of your Google Contacts with just one keystroke. This makes it quick how to create an email blast in Gmail and easy to start passing out targeted emails. It additionally lets you evaluate the campaign settings prior to releasing the newsletter to clients ensuring everything looks satisfactory.
If you want to utilize this tool with a Gmail mailbox, you'll require downloading it as a Gmail extensions add-on from Google's marketplace. The free version of Mail Merge is limited to sending to Fifty people every single day. While customers who purchase the paid version may send an email to a maximum of 400 individuals at once.
You can use the following steps on how to use a mail merge effectively.
Ensure that you've downloaded and set up Right Inbox. The premium plan is required for the mail merging features for more than 300 recipients.
Log in to your Google Mail account. At the left end of the Google mailbox a mail merging option will appear; choose it.
Make sure it includes the correct receivers. Users have the option of either uploading a spreadsheet called CSV containing the recipient's email accounts or entering them individually.
Join this by adding your own email address. Turn on the promotion's mail follow-up notifications.
When you want to boost response rates, review the email and customize each individually.
Modify the pace at which emails are sent and whether or not they are being tracked. You may initiate the mail merging after you have validated what you want.
Another efficient method how to mass email in Gmail at once is to employ a reliable email marketing service. Email template builders like Stripo make it easy to how to send out a mass email on gmail quickly and efficiently.
More than 1300 professionally-designed Email templates
are already included, and customers may test out the tool's drag-and-drop functionality before committing to a mass email strategy.
When you're done with an email, save it as a draft in Gmail and hit the "Send" button to send it out to the targeted audience.When you use one of these services, you can be certain that your mass email will reach its intended recipients safely and in the most effective way possible.
Using the help of the resources provided by mass email marketing firms, advertisers can monitor the success of their campaigns and adjust their strategies accordingly.
Many businesses and email marketers rely on mass emailing as a primary strategy for keeping up with the fierce competition in today's online marketplace. Any business may benefit from using a mass emailing service because of the time and effort it saves. Specifically, it allows for the tracking of metrics like audience size and monetary gain to gauge the success of advertising campaigns.
Using a bulk email solution is essential for even the greatest small businesses in this industry. We've compiled a number of strategies for using Gmail to send out mass emails, which you can view above. Hopefully, you found some useful information in this article.
Hello pupil! We hope you are doing well with object-oriented programming with Python. OOP is an extremely important topic in programming, and the good thing about Python is that the concept of OOP can be implemented in it. In the previous lecture, we made a basic introduction to all the elements that are used in the OOP, and right now, we are moving forward with the detail of each concert with examples. The imperative nature of the OOP is useful for us because it uses the statements to change the programming state, and in this way, the working of the code becomes easy and effective. To use the applications of Python, the imperative nature of OOP will give us the tools we need to get the perfect results by using our creativity. We will prove this in just a bit, but here are the highlights of the topics that will be discussed.
How can you describe the OOP by using an example?
Why are classes important in OOP?
Discuss the example and syntax of code when we use classes in OOP.
What are objects?
Give us an example where multiple objects are made if one class and the information are given by the user.
Discuss the basic features of objects in OOP.
How do you classify the attributes of objects?
What are the behaviours in OOP?
All of these are important to learn so pay attention to each and every concept and if you have any confusion, you can contact us directly.
Before going into the details of the OOP, now is the time to discuss why we are emphasizing the importance of the OOP and how we explain it with Python. The whole concept will be clear with the help of the following example:
Think of a dog that will be taken as an example by a class. Here, we have taken a general example that is common in the real world. Think of all the characteristics of the dog that may be either physical or natural habits of the dog. The general class of dog may have many types, such as the breed of the dog. There are hundreds of breeds of dogs, and these are considered the basic members of the class "dog."
Moreover, different dogs have different kinds of attributes such as their size, colour, skin type, age, and other characteristics that are said to be their instance attributes. On the basis of these attribute, the division of the dogs is done into different classes.
Moreover, the way the dogs bark, their favourite food, and their daily routine make them more specific, and these are referred to as the methods of that particular class.
The class is the basic unit, without which, the programmers may not think about the OOP in any way. This is the prototype with which the whole OOP process is carried out. You can think of a class as the blueprint of the house (let's say). In this way, the information about the floor, walls, rooms, windows, doors, etc. In this way, the whole house is made by following this blueprint(class) whereas, the result, that is the house is the object. Let us prove all this information with the help of this example.
The class is simply made in Python with the keyword “class” and the name that we want for our class:
class myClass:
# class definition
Here,
class=keyword
myClass= the name of the class given by the programmer.
In this way, with the help of simple lines, the creation process of the class is carried out. Now, the definition of the class is in the new line. To make a clear difference, a colon is used after the name of the class. You must keep in mind, the class name is a single word, no matter what the length of the name, and there must be no space between the name of the class.
In the example of the class given above, where we were talking about dogs. We are using the same example and will show you the result by using them in the example. To start with a simple example, the class with only three attributes.
#declaring the class
class myDog:
#defining attributes
def __init__(self, name, age):
#using the attributes and storing them in the new names
self.name = name
self.age = age
#usign the stored name to print the results
tinku = myDog("Tinku", 2)
print("The name of the dog= ",tinku.name)
print("The age of the dog= ",tinku.age)
Let's see what happens during this code:
First of all, we created a class with the class keyword, and this time, we named it “myDog” so you are providing the information about your dog( if you do not have it, just imagine it) and we are writing the particular features of that dog. So, the class is myDog, and all the other features are its attributes.
In the next step, we are defining the characteristics with which we want to describe our dog. Here, name and age are the attributes. That is taken as one of the two arguments we are defining to use later.
The "self" keyword will tell us that name and age are the special attributes that we want to use here.
In the end, a new unit is formed, where this time, we are using the values of attributes instead of the names. The first step was only to give the base of what we wanted, and this time, we will assign values to these attributes.
You can see, the name is in the form of a string, therefore we have used a double quotation. In this way, we do not have to specify the data type but just represent it in a specific way.
In the end, it's time to print the result and to make the message clearer, we used the written message and then declared the value we wanted.
We can add more and more attributes to make the class clearer and store data about the dog, such as its colour, fur type, etc. This is a simple example to show you how the class works.
The workings of the class are not just limited to one product. This is the good thing about the OOP is, it provides us with the versatility to work in a different way with the same code. In the example given above, if more than one breed of dog is to be stored, then we will make the objects of the class "dog."
To understand the objects in interesting ways, we are moving towards real-time applications where different objects are made and then used in a specific way. Let us take an example where we have different types of dogs with different ages, and the combination of the ages of the first two dogs is the age of the third dog. So here is the question that can be asked of you in the examination.
Write the code to get the age of a dog that is the combination of two dogs and get the input from the user for it.
#declaring the class
class myDog:
#defining attributes
def __init__(self, name, age):
#using the attributes and storing them in the new names
self.name = name
self.age = age
#using attributes in string message
def dogInfo(self):
print(self.name + " is " + str(self.age) + " year(s) old.")
#printing queries and getting input from user
print("What is the age of happy")
AgeOfHappy=input()
print("What is the age of sunny")
AgeOfSunny=input()
AgeOfFancy=int(AgeOfHappy)+int(AgeOfSunny)
#using the inputs to guess the age of fancy
print("Age of fancy= ",AgeOfFancy)
#printing results
happy = myDog("Happy", AgeOfHappy)
sunny = myDog("Sunny", AgeOfSunny)
fancy = myDog("Fancy", AgeOfFancy)
happy.dogInfo()
sunny.dogInfo()
fancy.dogInfo()
This program has many interesting features, and these will become clear with the help of this discussion.
At the beginning of the program, the class “myDog” is created so that we may give the same attributes to different objects.
To declare the attributes we are using here the “def” keywords to define the keyword then the
Attributes are mentioned so that we may use them later.
The next step is to define the message, in which we will use the attributes and get the result in the form of a message. Here, the point to notice is, we are using the string keyword for the "age,” but how can age be a string? Actually, we are using it in the string message, and if we declare the “int” here, the compiler, when it reaches this point at the output, will throw the error and not print the whole string.
After that, the whole mechanism is used in which we are printing the message to input the age of the first two dogs and get the output in the form of integers.
Here, if the user inputs a data type other than an integer, it will also result in an error.
Both these ages are then added, and the result is saved in the “AgeOfFancy” variable.
The object we have just used to print the results.
So with the help of this discussion, we come to know that the object consists of the following features:
Each object has its own set of attributes, which are variables that store information about the object's current state. We can say that objects are made of attributes. Yet, there are different types of attributes in OOP, and the following are some of the most important characteristics of attributes:
Instance variables: These are defined within the class but are unique to every instance of the class.
Class variables: These are also defined within the class but are shared with all the instances.
Methods: These are used to manipulate the object’s state and are defined within the class to operate the attributes.
Special methods: These are also referred to as the magic methods and these tell the compiler how objects will behave under certain conditions. These are denoted by the double score in the name as we have just used in the previous code of dogs.
Inherited attributes: These are used to reuse the modularity in the code as these are inherited by a subclass or a superclass. So it makes working easy.
When an object is created in OOP, it has its own set of behaviours, which are defined by the methods in its class. These methods can be used to change the state of an object. Another function of the behaviour is to carry out other operations related to the object's behaviour. For example, if we declare the object of a car, we might have methods such as:
start engine()
accelerate()
brake()
turn()
These methods define the behavior of the car object and enable it to perform the actions that are expected of a car. These are just simple examples, and we can add more and more behaviors, just as a car can do hundreds of tasks.
Hence, in this lecture, we read a lot about objects and classes. There are different entities that are used in OOP, and objects and classes are the basics. We must know that objects and classes are used simultaneously, and for a better understanding, we learned the classes first and then examined where and how objects are being used. Moreover, different types of objects and fundamental knowledge about their pillars are discussed here. We have a lot of information to share with you, and you must have noticed that Python is now more complex but useful when we use the concepts of OOP. We have some mini Python projects to share with you in this tutorial, so stay with us for more programs.
Hey peeps! Are you excited to begin with the new chapter in Python? Till now, we have been learning the data types and their related concepts. Now, we are starting a new chapter where you will learn the details of Object Oriented Programming or OOP. We are moving towards the advanced level of programming in Python, and here, you will go through the complex but interesting concepts that will show us the fascinating results on the screen. This will be more clear when you will know the basic information about the OOP, but before going deep, we will go through the headlines of the lecture:
How do you classify the programming languages?
How do you introduce the OOP?
Why object-oriented programming is important in Python?
How do you define class and objects in OOP and how are they connected?
What are polymorphism and encapsulation?
How do you use the inheritance in OOP?
How do you understand data abstraction in OOP?
What does method overloading mean?
Keep in mind, it is not a specific concept with Python but any higher-level programming language that supports the OOP has the same concepts and we are using a very general way to describe all the concepts.
Before going into the detail of this topic, it is helpful to understand why we are emphasizing on the OOP and its importance. Actually, there are different types of programming languages and being a programmer, you must know the basic categories. Some of the important types of programming languages are:
Procedural Programming Language
Functional Programming Language
Object-oriented Programming Language
Scripting Programming Language
Logic Programming Language
Out of which, we are interested in the OOP. The reason why the type of programming language is important, it describes the paradigm of the language, and therefore, we can understand the nature and the importance of that particular language in the profession you are using it for. Here, we should know what exactly the “paradigm” means:
“A programming paradigm is the concept to which a programming language's methodology adheres."
Paradigms are significant because they define a programming language and its operation. The classification of the programming languages is done by keeping its paradigm in mind and in this way, the programmer may choose the type of programming language that exactly suits the application for which the coding is required.
You can see that OOP comes in the imperative paradigm. In imperative programming, the user typically interacts directly with the computer's state, deciding how things should be calculated. In this way, more control is in the programmer’s hands, which is the basic source of attraction towards this programming language. In the practice of programming, I am sure you have touched other types of languages as well at any point. So, it becomes easy to compare and practice the code.
In real-time education, different types of subjects are taught to us by teachers. We are moving from basic to advanced programming in this course; therefore, we have covered the concept of data types before. This time, the OOP is our source of attraction, and we are going to learn it deeply because the programmers, most of the time, deal with the OOP when they are using the practical applications of the programming. Let us look at the introduction to the OOP:
“OOP (Object-Oriented programming) is a programming paradigm that organizes and structures code using objects and classes.”
For now, do not bother about the special terms used in this definition. We will learn a lot about them in these lectures with the help of different terminologies. Hence, if anything is causing confusion, do not worry because everything will be clear in just a bit.
The concept of OOP is so vast and important that it is widely used to write powerful applications. The data engineers have to write these applications to access and use the data stored in different entities.
The feature that makes the OOP unique is, it uses concepts that not only make the programming easy but efficient. It is based on the imperative programming paradigm, which employs statements to alter the state of a program. It is concerned with describing how a program should work. One must keep in mind that the main objective of the OOP is to bind the data and the functions of the program in such a way that all of these may work as a single unit but the security of the data remains intact. There are some important terms that you will see often in these lectures, so have a look at all of them.
Class
Objects
Polymorphism
Encapsulation
Inheritance
Data Abstraction
Keep in mind that you have to grasp the concept of each of these terms clearly so that, when you read them with other types of definitions, you may not be confused. You will learn all of these in detail in the coming lectures, but the basic introduction to all of them is given next:
Before going into the introduction of the OOP, one must know that an object is an instance of a class. Object and class are interconnected terms, and a class is defined as:
“In OOP, a class is a basic unit that represents the collection of objects, and it can be thought of as the blueprint or the prototype by following which, the objects are made.”
The attributes of a particular thing, connected with each other, can be represented with the help of the class, where the number of the attributes starts at one and can be two, ten, or any other positive number. In this way, a simple and basic class can be used to store all types of physical or logical information about a particular product.
In object-oriented programming, objects are the basic units of data. An object is associated with the class and is the entity with which the state and behaviour of the class are associated. If it is confusing at this point, do not worry because we are going to discuss the object in detail and will work again and again with the objects.
The good thing about the objects in OOP is that, just like the real-time concept of objects, the programming objects may be anything, whether it is physical, such as a car, an animal, a plant, a cooking item, any food, or any other thing, or abstract, such as any software, a bank account, a soft blueprint, or any document. The positive thing about the object is, it allows us to reuse the same code anywhere in any block of the same code where the same attribute of the object is to be used.
The fundamental concept of the OOP is polymorphism, and it has the same features as the family in real life. To keep things simple, we assume that all the objects belong to the same class, and the polymorphism allows us to use the objects together as they are from the same family. In this way, the same objects can be used interchangeably in the same context. In this way, the workload of the programmer is minimized as much as possible through polymorphism. In simple words, the concept of polymorphism is the same as it is in chemistry, where the same element can be used in different ways when certain conditions are met.
Another feature that makes the polymorphism attractive is the availability of the alteration in the classes, both in terms of their size and the data stored in them. All this information will be cleared up in the coming lectures, but for now, we only understand the basics of polymorphism. In other words, we all know that poly means "many,” and if we talk about OOP, it includes the concept of a class's ability to get the features of already existing classes in this way. For example, you can assign the attributes of a particular product, such as a car, to another car with the same basic features but with different attributes. This is just a basic example of polymorphism, and many people mix this concept with inheritance, but these are different, and you will learn a lot about them in the next lectures.
The next concept that we are going to discuss is encapsulation, and to make your concept clear, let us take the example of the capsules that we get from the pharmacy for different health issues. These capsules protect the inner medicine, and the same concept can be applied to this type of encapsulation to reinforce the concept. Basically, the data is protected with the help of different concepts used in the encapsulation.
The programmers are very sensitive about their codes and the data stored with the help of these codes. Encapsulation is used to give the code privacy and protect it from unwanted users. The private attributes of the code that are enclosed in the capsule are only accessible by the programmer itself. In other words, we cannot use the private attribute in other blocks of code until the programmer himself allows it.
Another important feature of the OOP is inheritance, and this is the point where we can say that the OOP is making Python more effective and easier to use. It is one of the most significant points of the OOP, and with the help of easy and effective Python, programmers can inherit the characteristics and attributes of any class and assign them directly to others. For this, you have to learn about the child and parent classes, but for now, we are leaving this topic here and moving on to the next point that will show us the importance of the OOP, especially when we use it in Python.
If you are interested in becoming a professional programmer, then some points should always be kept in mind, and the most important one is to always go with clean code that precisely describes the code and gives the exact coding without any errors. For this, some concepts will help you a lot, and one of them is the concept of data abstraction. With the help of this concept, the programmer is able to code cleaner because "data abstraction" means writing cleaner code and hiding unnecessary details from the users. It is yet another method for the programmer to maintain privacy from the end user. THE SENSITIVE CODES ARE HIDDEN FROM THE OTHER USERS USING DIFFERENT TECHNIQUES. The whole process of data abstraction revolved around making and implementing the abstraction classes and then calling them in different ways according to the requirements of the code.
Here is a small topic to be discussed that is not a particular part of OOP in Python, but almost every programming language that works with OOP has it. This is also true for other characteristics that we have discussed so far.
In method overloading, many methods with the same name are declared and then called at once. In this way, a single class can take multiple arguments. Other concepts, such as method overriding, are also connected with the same concept, and we will discuss them with some suitable examples.
Consequently, we have almost all the basics of the OOP. We have read a lot about them and tried to make them more general so that the programmers working on them other than Python may also get the useful concepts from this lecture. Actually, the OOP is not just confined to Python, but we have to connect it with Python, and this will be more fully discussed in the next lectures, where all these concepts will not only be discussed but the practical implementation of codes will help us to have a grip on Python. This is an extremely useful topic and therefore, we will move a little bit slowly on these lectures and will understand each and every point in detail.
Hey peeps! Welcome to the new tutorial for the Python programming language, where we are at the point where we are going to learn about the loops. Loops are fundamental concepts in programming, and if we talk about Python, there is a smaller variety of loops in it, but the most important ones are available to practice in Python. In the last session, there was a long discussion about the while loop in detail. We had seen some examples and the details of the statements that can be used within the while loop. In the present lecture, we are going to discuss the second type of loop in Python, that is, the for loop. You will go through the training of every important and basic step about this loop, but first of all, you have to look at the basic list:
Why do we prefer for loop over some other concepts in Python programming language?
What are some basic concepts that every programmer must know about the for loop in Python?
Describe the flow chart of the for loop.
What are some examples that explain the for loop in Python?
How do we use different sequences in the for loop?
What is the range function explain it in detail by using the for loop in Python?
There are other ways to get the same output as we will get in this lecture but using the for loop is one of the easiest and most fundamental ways to get the best results. Have a look at the detail of each question.
The for loop is the basic looping process in Python that is extremely useful in making the basic to higher level codes in simpler way. We all had the introduction of the For loop in the previous lesson, and now, have a look at the following positive points about this loop:
The for loop makes the code very simple and the programmers do not have to pay much attention to make the logic. You can get the idea of its simplicity that the user can initiate the loop in just a single line if all the logic is clear in it. After that, the body of the loop starts. Just like other loops, the For loop gives us the independence to adjust the flow of the code so that we do not have to write the same block of the code again and again.
Different data types can be used in the for loop and the best thing about it is, it becomes super easy to use the For loop to manage the sequences. It would not be wrong to say that For loop makes the working of the sequence best therefore, for loop is perfect for the sequences such as lists, tuples, and arrays. Moreover, the traversing of the sequences is easy with the For loop.
The for loop is not a new concept but in the old higher-level programming languages such as C and C++, for loop is used therefore if a programmer is moving from such basic programming languages to Python, the concept will be cleared before they start it. In other words, the for loop is a generic type of loop that once understood, can be useful as well when they switch to the new programming language.
We know the introduction of the for loop but this time, we are going to discuss the detail of every process that will be useful in the practical coding using the for loop. Keep in mind, loops are the statements and not the whole code. This helps to manage the code in a better way and to reuse the same block by merely inserting it in the body of the loop.
We are discussing the generalized form of the For loop and therefore, all the concepts are very general that we have discussed till now. Yet, the only difference in the coding is the syntax of the loops and therefore, we are discussing it at first to get an idea of what actually is going on.
for iterator in sequence:
statement(s)
It seems very simple here but the statement is not that much simple. The programmers, then using the for loop add multiple statements in different ways to get the required output. More things will be cleared when you will see the flow chart.
The best way to get the concept of the for loop is to check for the flow chart of this loop. Have a look at the picture given next and then we will move towards its discussion.
Here, you can compare the syntax and flow chart and get an idea of what happens when data is input in the for loop. At the start, when the condition is applied on the for loop, the compiler checks for the condition if it is true or not and as you can guess, if the condition is true, the compiler will check for the body code
Different data types can be used with the for loop and we will move from basic to complex ones. We all know about the string; therefore, here is the first example with the string message.
#initializing the message
message= print("Enter the string")
#taking input from the user
str=input(message)
#using for loop to print the message from the user
for i in str:
print(i)
Here, when we run the program, we get the dialogue box it says the “none” word with the dialogue box. This will look strange but it makes sense. With some functions in Python, the return value is mentioned in the output. Since this function will not return any result but will only give us the same string that we are going to input in it, therefore, there is the word “none” mentioned in the dialogue box. We can solve it in different ways but the point I want to make here is to clarify the reason behind this indication.
When the string message is typed by the user, the same message with the same format is shown on the screen but this time, as we are using the for loop, each character is picked by the compiler one after the other and therefore, the result will be obtained in the vertical form with each character at the new line.
Here, you can see the “none” is added by default without a string message and once it is printed, the for loop picked each character and printed it in a separate line. Even the spaces between the words are counted, and we get a clean and understandable output.
Have you tried the code given above? If yes then there must be a question in your mind that what happens if we input any other data type instead of string? Actually, this is not a precise code yet, if we add the restriction to add only the string as we have done in the previous lecture, the compiler will not accept any other data type other than string. Yet, to keep things simple, I am not changing the code as the main focus is on the for loop till now.
Here comes the practice that is specialized in the for loop. Since the beginning, you have been noticing that we are emphasising the sequences. We all have practised them and in some examples, the for loop was used before but since this is a pure practice of the for loop, I have made a program that contains all important sequences in a single program.
#initializing the List to use with the For loop
print("\b Names of the fruits")
fruits= ["strawberry", "cherry", "blueberry", "apricot", "tomato"]
for i in fruits:
print(i)
#initializing the tuple to use with the For loop
print("\b Price list of mentioned fruits")
priceOfFruits= (34.8, 11.7, 126.9,11.6,11.5,22.0,1)
for i in priceOfFruits:
print(i)
#initializing the array to use with the For loop
print("\b Random things and numbers")
items= {"lipstick",3,"papers", 3, "pen", 1, "bread", 3.4 }
for i in items:
print(i)
Hence, the program is clear as we have practised it before. The type of bracket represents each sequence and it has its own characteristics. For loop access each and every element of the sequence and print it on the screen. The arrangement of the items in the array is random and we can not suggest the sequence of the elements because it randomly picks the elements and print them. Hence, every time we run the code, the value stored in the variable i is different and the one, printed on the screen, is never repeated at that particular run time.
The next topic here is the range function that has interesting applications in the fields like gaming. It is because it can be used in different ways as it has the independence of the number of parameters. The syntax of the range function is the same with the for loop as it is with other statements.
x=range(start, stop, step)
Where,
x=name of the variable in which the value of the range is being stored.
start=starting point of the series
stop=ending point of the series
step=The interval between the range member.
Keep in mind, you can use one, two, or three parameters at the same time according to your easiness. Instead of using separate examples for each case, we have designed a program that describes the all. Have a look at the code and then we will discuss it more.
#using the range function to print the table
num = int(input("Enter the integer for which the table is required? "))
for i in range(1,21):
print(num,'x',i,'=',num*i)
#range function with one parameter
print("\b using the range function with only ending point")
for i in range(7):
print(i)
#range function with two parameters
print("\b using the range function with starting and ending points")
for i in range(2,9):
print(i)
#range function with three parameters
print("\b using the range function with start,end, and step points")
for i in range(1,10,3):
print(i)
For your convenience, we will go through the basic to the complex concepts.
The three parameters are useful to get a uniform series of numbers.
Only integers can be used with the range function.
If the start point is not mentioned, it always starts from zero.
The stop parameter is the compulsory one to use in the range function.
To make the restriction of only integers, the “int” keyword is used with the input function in a specific syntax.
You can get the table of any number with the range of any integer easily using the range function.
For loop is the best way to get the required output from the range function.
Consequently, we can say that we are not beginners and instead of learning the long theories about the basic concept, the focus of our lecture was towards the practical examples of the for loop therefore we started this lecture with the introduction and then moved towards the basics, syntax, examples, and the codes using different data types. As the specialized data type of the for loop is sequence, therefore, we had the practice of the for loop with the sequences. Using the range function with for loop gave us the interesting outputs and with the help of these examples, we learned the for loop in a better way. The upcoming lectures are interesting tooo so keep practicing and stay with us.