Subtitles

python data

  • Writer

    th*****

  • Subtitler

    -

  • Upload Date

    2021-06-08

  • Language

    မြန်မာ

  • Downloads

    103

  • Video title

  • Subtitle files

    subtitle.srt [550.86 KB]

  • Description
    I'm going to talk about the focus of our course mastering Python for beginners in data science.
    So let me explain what kind of areas in this particular course we are focusing the most.
    In fact, because this is a course, for beginners, that's a beginner level course, we are not
    assuming the the course taker to have any experience whatsoever about any computer programming
    language before, not even not even the problem, problem solving paradigm that lies in computer
    science. So, we will, we will focus on problem solving for a bit. And we will actually start
    from the very beginning what problem solving is, particularly in computer science. The
    second focus of this particular course, is mainly telling you why we are choosing Python,
    why Python is so important, particularly for data science problems. The third focus and
    the main core focus is to learn Python, obviously, once we know what is what what are the techniques
    to solve a problem. And once we know that Python might be a very good language to go
    with, then what is Python, how to learn it? Well, the Python is the main core and main
    focus of this course, obviously, we will start from the very beginning, very, very beginning,
    which means we will start from how to install Python for example, we will start from there,
    and then we will see what are variables, I mean, very, very beginning, and then progressively
    we will be moving on and on and on to data structures to complex structures, but that
    transition from 02 onwards, that transition will be very, very smooth. I mean, whatever
    you know, so far, in the course, that will be helping you to gain more complex structures
    very, very easily getting the understanding of a lot of structures very, very easily.
    So in this Python, we will include all concepts of Python in general. And, and one more thing,
    after I mean learning, despite on the way we the way we organize this course of learning
    this Python, you will be having an understanding of other languages as well. I mean, the contents
    here are explained in so general way all over the Python syntax, but the general but but
    but the concepts are expressed in so general way, the problems that we picked to solve
    for practice are so generic that you will after this particular Python course, you will
    be having understanding of programming languages in general. So data science is one other focus
    of this course, actually, the whole course is organized in a way that it teaches you
    about Python, it teaches you problem solving, it teaches you something about overall programming
    languages and how computer can be used to achieve the solution of different problems.
    And and using Python, of course, and then we will be introducing the data science packages
    that are available in Python, because they are really, really fast, really fundamental,
    very easy to use, and very, very powerful to handle large amount of data very quickly
    for data understanding for visualization, for cleaning, processing, and a lot of stuff,
    what we are not focusing at because that's important. Knowing that what kind of things
    are are are the things that we are not covering, for example, we are not covering object oriented
    programming, we are not covering exception handling, we are not doing web development,
    or any general kind of tasks that are doable in Python, we are not focusing on those things.
    Everybody solves different problems every day. Some problems are easy to solve, and
    some are difficult. And yet some are impossible to solve. They are called unsolvable problems.
    But think about different instances of the same problem one needs to solve again and
    again. For example, sorting the sale records. And let's say we are sorting the sale records
    with respect to the sale value. And we have to do it after every eight hours. If the number
    of instances if that number is huge, the optimal choice is to automate the solution if the
    automation is possible, but how how to come up with the automated solution to come up
    with a general solution that works for every instance of some problem. That is one thing.
    But to get that solution running on a computer is yet another thing
    Problem Solving deals with formalizing a general solution for that works for every instance.
    And programming languages, like Python deals with the running of that solution on a computer.
    Python, as, as we will see, makes the transition from problem solving to the running solution
    much easier and quicker. And that's one big plus of Python. A lot of words, I know a lot
    of words. Let me take an example to clarify what I said, Hold on till the end of this
    video. And I will make everything what I said so far, crystal clear. So let's take an example.
    Let's dive into an example to see what I just said. Let's say your a, and your friend is
    B. And your friend B is always willing to help you. Let's say you found such a friend.
    And then a just said, I want off just for some days. But be said, but what ghobadi enjoy.
    He said, someone have to do my job in my absence. And then be said, That's it? Is that your
    problem? I'm available? As always go buddy, enjoy. Man. He said, great. You're a true
    friend. Okay, I'm leaving, wow. And be just said, Hey, wait, what do I have to do? What's
    your job? At the end of the day, I'm going to do your job. What's your job? What do you
    do? And then he said, after every eight hours, pick the email of the customer when the maximum
    sales. So that's what you have to do. He said, Okay. But from there, I mean, I have to pick
    that email of the customer from where, where are the records? He said, Well, there are
    sales records. I mean, at the job place, there are sales records. And you have to pick the
    email of the customer with maximum sales. We said, Oh, okay. But wait, what, what should
    I do with the email that I just picked? Then he said, oh, there is an other record called
    priority records, just write that email after eight hours, just write that email in purity
    records. And then be said, that's it. That's all your job. And he said, after so relaxed,
    he said, Yes, that's my job. That's all. No, think he leaves and later that day receives
    a call from B. And B said, I don't really know what to do. Can you tell me step by step?
    What to do? Focus on again, I'm reading this particular sentence again. Can you tell me
    step by step what to do? I have sales records with me having all the records for the last
    eight hours, what to do, I just messed everything up. I don't know what to do. And then at the
    call, he just described a procedure to be for his job. That procedure or a general solution,
    let's see the solution. He said number one, start from the first record, there may be
    several columns of the record, the customer name, the customer phone number, the customer
    email, the customer products that he buys and the total sales. And in the point one
    said, he said, start from the first record, and focus just on the sales column. Okay,
    then, then after that, go to each next record one by one, and find the record with a maximum
    sales. Obviously, once you have focused on the sales column, you're just comparing sales
    of different records with each other and will eventually come up with a record that have
    maximum sales. Number three.
    If there are more than one records with maximum sales, it is possible that the maximum sales
    value let's say is 100, whatever the units are, and there may be two or three or maybe
    five records with the maximum sales 100. Then which one to pick, as described here in Step
    three, that if there are more than one records with maximum sales, then pick the first one
    from top to bottom and ignore the rest I mean, whichever is the sole. So let's say you have
    five records with maximum sale value, which record appears first from top to down, just
    pick that one and ignore the rest. That might be a policy that might might be a tie breaking
    policy, but just do that. And then the fourth step is focus on the email column of the record
    you found in step three. In Step three, you found a column with maximum sales. Step five,
    see the email address and write that address in the priority records. So that's for the
    eight hours, then repeat this process, see the step six, then repeat this procedure,
    after every eight hours, I'm gonna repeat this procedure, I mean, you'll see the the
    solution a is communicating to be in in this in these kind of steps. It it gives me It
    gives a precise idea of what to do. Still, there may be some, there may be some questions
    to be is maybe asking, for example, B may ask how to find out a maximum, B might be
    that person who don't know how to find out the maximum. And third, for example, another
    question we might may ask is that when when I'm going to write the email address in the
    priority rock records, where should I write at the very top or at the end or somewhere
    or, but at the end of the day, a solution a step by step solution is required for communication,
    this kind of if you see the solution, although it has some it may be explained in there may
    be more steps that should be added, but if you see the solution, the step by step solution,
    this is a general solution. This is a general solution, much more general solution for every
    instance, but every instance I mean, after every eight hours, you will be having some
    records, and you have to do this procedure on the records for that eight hours. And then
    after that, that after that eight hours, you will be having more records to work on. So
    after every eight hours, you have the same, the problem is the same, but the instance
    is different, because the records after eight hours are different. But but the but the solution
    says whatever the instance you are right, right now, whatever the instance is that you're
    in, just perform these, these steps, a step by step solution, coming up with a step by
    step solution is is one module of the one module of the problem solving. And there's
    step by step solution is called algorithm.
    algorithm. Obviously, the step by step solution is not always required to be communicated
    in plain English or in natural language, you may come up with shorthands or shortcuts to
    explain these step by step solution. So, the the more shortcuts the more precise and unique
    meaning keywords you use in your step by step solution, the more better communication of
    your solution takes place. And going from this step by step solution, which is just
    in plain English, going from this to a more concise and unique kind of procedure, that
    that can that kind of work that one step that will take us from there to there, that we
    will see in the next video will be called a pseudocode. And from that pseudocode there
    will be few steps that will take us to the second major problem that the problem problem
    languages will solve the get the solution running on a computer. So I'm just just in
    this video i i wanted to explain you that solving a problem may not be that hard, I
    mean, coming up with a coming with coming up with a solution of a problem may not be
    that hard, but communicating that solution or, or writing that solution in a form of
    procedure that can solve every instance of that problem that that requires a step by
    step treatment of the procedure. And those those steps they should be linked in a sequence
    and they should be unambiguous. And if a particular step requires more elaboration, that step
    might be broken down to further steps. But that step by step solution at the end of the
    day is called algorithm. Now that algorithm might be in English, but we will see in the
    later video that there are better ways of expressing algorithms better than English
    or better than natural languages. So, so, if you have another problem come up with a
    step by step solution of that, though, every instance of that problem should be solved
    by that step by step solution, which is called algorithm. And in the next video, we will
    see how to actually how to actually eliminate the need of having English with us and how
    to incorporate the uniqueness of understanding of these steps or algorithm using using the
    concepts of pseudocode. And after the pseudocode, we will see it will be very quick to jump
    to any programming language and we will see that the Python is very close to what humans
    generally think, I mean, it's very easy, the transition will be very, very easy. So, hope
    to see you in the next video and I'll be explaining algorithms in in, in a in a more kind of keyword
    way. And, and in the same video we'll be focusing on pseudo codes which are basically pre step
    off of the actual core of any programming language. So, hope to see you in the next
    video. Okay, in in the last video, we were talking about the algorithm what an algorithm
    is and how to express that any any algorithm and we saw that algorithm is just a step by
    step procedure. But, but how to express an algorithm may vary, I mean, you need not always
    to have plain English to or any natural language to express algorithm. The reason is that the
    natural languages are normally so expressive, and each and every sentence they may have
    multiple meaning. So, it is it is a good idea to come up with a structured way to express
    an algorithm such that each and every statement is completely unambiguous. And one such way
    is is to express algorithms using flowcharts flowcharts are our graphical ways of expressing
    algorithms. Here we are taking. The problem here we are discussing is is computing PE
    of different employees of some company. And the procedure of I mean, if there are several
    employees, let's employ one employee to employ three and so on. Let's say there are several
    employees in a company and having each employee has name, phone number, email and all the
    credentials. And then let's say the pay is computed on hourly basis, and each employee
    has worked certain hours for example, eight hours and each employee has an hourly rate
    might be let's say 100 units, whatever the units are
    employed to might have worked for example, seven hours, but the hourly rate of this employee
    might be 200 different employees, they might have worked for different number of hours,
    and each employee can have a different hourly rate depending upon the capacity of the employee
    or the or the job nature the employee is doing and so on. So, so, so, if we want to compute
    pay of all employees, one by one, the procedure of computing pay is stays the same, the instances
    they differ for employee one, the value of our is eight the value of Raiders 100 for
    employee to the procedure will stay the same the values of our end rate they will differ
    so what should be the procedure, the procedure might be that you take the take the input
    of let's say employ one or whatever employee you are going to compute salary for take the
    hours hours value in a in a placeholder call that place or call that placeholder as ours
    placeholder or a variable y this is called a variable because for different employers
    this value will different will be different, ours will take value eight for each one employee
    one this this variable, this placeholder will take value seven for employee two and so on.
    Similarly, once whatever employ whatever employ for which you are going to compute the pay,
    if you have taken the hours from some records from some working records, then take the rate
    for the same employer as well. So input this that step one in Purdue that is step two,
    the steps the sequence of these two steps may change for example, you take the you take
    the rate value first and ours value later than that, but either way, that's one way
    of that's one way of expressing this this procedure. And then you compute the pay by
    this formula. So hours multiplied by rate. So maybe this is confusing writing a star.
    Maybe maybe We should write this cross symbol because that is more common in mathematics.
    Or maybe this whole line can be replaced by, by this particular line, maybe. So pay is
    equal to multiply hours. And rate. Maybe this is more expressive, but it completely depends,
    I mean, when you start writing pseudocode, or whatever pseudo codes you're writing, what
    kind of keywords begin is a keyword and is a key word, what kind of keywords you're using,
    and stay with those keywords for example, if the keyword input is to use to take to
    get the values to to process on then the input should stay everywhere wherever we want to
    do such kind of operation. If you if you're using for example, the value get rather than
    input then use get always but come up with some set of keywords that are expressive,
    as well as concise and then take the sequence of those statements, each and every statement
    should be should have a unique meaning, it should not be ambiguous, and the sequence
    should be in the sequence describe the flow of what is happening, what is going on. So,
    first we take hours, then we take rate these two values for for for any kind of employee,
    and then we will just multiply them and after multiplication, whatever the scene we want
    to make, based on this pay, we will do that, we may we may record this value, display value
    at at some other records register, we may we may print that value on a print slip, we
    may have emailed this value to some other department or whatever to see and we want
    to make, but the procedure really is still here, then based on pay whatever action we
    are going to do that that may differ. Similarly if we go this is this is I mean, some kind
    of structured example of, of the, of the expressiveness of an algorithm which is called pseudocode.
    And what kind of keywords you're going to use, there are no general keywords, I mean,
    some people may use get some people may use different kinds of keywords for it, but it
    is good to come up with a set of keywords to to describe the describe the solution of
    the solution of the problem in flowchart for example, everything every every statement
    here, that is here in in pseudocode every statement is described as a shape different
    shapes for different kinds of statements. If you want to take input, then you have to
    describe that action using a parallelogram. If you're going to do some computation, you
    have to express that using a rectangle the start symbol and end symbol the start and
    end of any procedure in flowcharts they are described by the ovals For example, this oval
    in that oval normally the flowchart sequences from top to down, but it is always good to
    just print the arrows to describe the flow, because in complicated flowcharts there are
    there are loops there are if conditions there are so many things. So it is good always to
    describe the flow using using arrows. So, now the question is flowchart or pseudocode
    because flowchart also looks like a very cool way of writing. expressing an algorithm and
    pseudocode is also a way of expressing an algorithm. Well, converting flowchart to actual
    programming code is somewhat tedious, writing a pseudocode beforehand, which is readable,
    which is precise, concise, as well as unambiguous then converting that pseudocode to code of
    any programming language, that is not that hard, that is simple in writing flowcharts
    for very complicated problems is somewhat tedious, because then it It also requires
    another transition from flowchart to reactive programming code. That's why writing pseudocode
    is more feasible, if the goal eventually is to convert that pseudocode to some core of
    programming language. So, you can go with flowcharts you can go with pseudocode either
    one is fine, but more feasible way of expressing algorithms is a pseudocode. That was just
    a very simple example. I mean computing, computing salary of an employee writing a procedure
    for that. I mean, this is so simple, nobody make your writing that kind of writing solution.
    have this kind of problem as a as an algorithm or as a pseudocode as a flowchart. But the
    basic idea is, is is is the same, even if you have a complicated problem if even if
    you have a problem with maybe many more steps, the idea is still the same. In the in the
    next video, we will we will see a procedure how to how to make tea for example, that might
    that may look look to you funny, I mean, do we really want do we really want to know the
    procedure to make tea? Well, the idea is not to learn how to make tea, the idea is to learn
    how to express the solution of this problem making tea that's a problem, the solution
    of this for how to how to express solution of that problem as as a pseudocode. And we
    will see one more example of flowchart as well. So hope to see you in the next video.
    Okay. In the last video, we saw flowcharts and pseudocode, we just took an example of
    we took a very simple example computing salary or pay of employee of a company given hours
    and rate. And I also described weatherflow, the the comparison between flowchart and pseudocode.
    And I said that pseudocode is closer to the core of some programming language, which eventually
    we need, because eventually we need automation of of a solution of a problem. And for that,
    we need a code of the digit the code for the solution, the general solution in some programming
    language, so flowchart and pseudocode, and then the core of some programming language
    like Python,
    it is somehow in sometimes handy to to break the problem or to devise a general solution
    of any problem for in first step in a flowchart because that is more expressive, and more
    generic, more general, maybe in a graphical way. And then once the proof of concept is
    clear, once it is clear that this is indeed a general solution, it has no bugs inside
    it has no errors, it will work always, then we can take another step to convert that flowchart
    to pseudocode. And then pseudocode can be converted to the the code of any the code
    in some programming language. But writing pseudocode right away, I mean, from the very
    beginning without flowcharts is also a common practice. Either way, whichever way suits
    you. In this particular video, I'm going to talk about problem the problem is making tea.
    You might be thinking, what are the different instances of this problem I'm in making tea
    is making tea. What what kind of different instances are there? Well, one person may
    be liking tea with, for example, 1.5 units of sugar, whatever the units are, and another
    person may want a tea with, let's say, two units of sugar, one person maybe, maybe needing
    a D with, for example, point five units of milk, and another one, maybe a different units
    of milk, and so on. So the procedure of making tea should stay same. And the instances which
    means the different people want tea in a different kind of combination that may vary. So let's
    let's like let's see a procedure first and flowchart. And then in pseudocode, for for
    making a tea, for making tea. So let's start that that might look like that might look
    you look to you a kind of funny kind of problem. But that's a genuine problem. For example,
    if you want to make tea, what is algorithm for this? So first we start and then the first
    step we do is we put teabag in a cup, that might be a first step. You can argue should
    this be a first step should that be the second step and so on the sequence of By the way,
    solving one problem, you can have multiple algorithms for that. And do different algorithms
    may just vary because of the sequence of statements even if you have the same statements. So I'm
    not talking about that the algorithm or the general solution is unique. You can have multiple
    different general solutions or procedures. So for example, putting a teabag in a cup
    that might be first step, or the first step might be the boil, boil the water and pour
    the water and pour the water in the cup and then put the tea back. Both are fine, I mean
    this way or that way. So let's start with putting a tea bag in a cup. So that's an that's
    an input. We take the tea bag from somewhere. That's our input last time, I do You that
    input is taken as parallelograms put a teabag in a cup and then forget about that cup and
    boil the water somewhere there is a water I mean take the water from somewhere and boil
    it and see if after let's say five or six or seven time units whatever the time units
    are, see if the water is boiled or not assume that there is a test that tells you that the
    water is boiled or not. So, there is a test available to you. So, you apply that test
    and check that the water is boiled or not if it is not oil then keep on boiling. So
    boil it again. And assume there is a procedure of boiling of water in in in normal case,
    boiling water is just happened by I mean keeping the temperature high or putting that thing
    putting the pot of water on fire or something like so, but that that itself is a procedure.
    So,
    while the water again and boil the water again check if the water is boiled if no then boil
    it again. If not boil again then check if no then boil it again this is called a loop
    this is called a loop or repetition you are doing the same kind of stuff again and again.
    Until there is a particular condition that is that is met. So in this case, the condition
    is when while the water is not boil, keep on doing the same procedure again and again.
    This is called repetition or loop. So you boil the water again, check the condition
    if the condition is true, for example, the water boil Yes, then come out. Then you're
    then you can exit this loop and come out. Then pour the water pour the water in in the
    cup. Here we should hear we should describe that is that the same cup or a different cup?
    Well, this see you pick up here is acting as as a placeholder where this tea bag and
    the water is going in. So we have a cup, we put teabag in it, then we put the boil water
    in it, but before pouring the boiled water in it. We just boiled the water. Okay, and
    then after we have water in a cup and a tea bag in a cup, what should we do next? We actually
    we actually first test one sugar or need more sugar? If yes, then then add sugar. So let's
    apply some arrows. If yes, add them add sugar. And then again ask do you need do you need
    more sugar? Or one sugar now? Yes, add sugar. One sugar. Yes, add sugar that is again a
    loop that is again a loop while while the while you want sugar. I mean you test that
    the sugar is okay or not. Here you test that the sugar is okay or not or whatever sugar
    you need. If Is that okay or not? Until that condition is not met, you keep on adding the
    sugar, add a teaspoon again, then test out a teaspoon that is again a loop or repetition.
    Once the condition is met once you know then exit this loop and ask what milk because some
    people just take tea without milk. Maybe somebody wants a milk maybe somebody don't. So want
    milk? Yes. So add milk. So that's that's a mistake this this loop should go there. There
    right there. And this line shouldn't be there. That's that's wrong. Add milk and then ask
    what milk? Yes, admin, that's again a loop. Once you exit the loop, then you ask need
    to steer. Yes, steer, then ask again. This line again shouldn't be there. So that that's
    another loop. Once you exit this loop, then the T is ready, you serve that D finish you're
    done with the procedure. Now let's see the same procedure in pseudocode program is the
    keyword and that's what program name is program make D what is a keyword put teabag in a cup
    while water not while while is a key word, while this is not while this condition is
    not satisfied, keep on doing this. Whatever written in while and while is is the body
    of this repetition are called loop. So while water is not boil, boil water. Then again
    check water boiler not know what again. I'm in keep on boiling. So this is repetition.
    Once the water is boiled, which means this condition is becomes false what not oil becomes
    false so water boil, then you exit this loop, you pour that water in cup, that's again a
    key word, you in a cup, and then you ask, okay, need sugar? Yes, add sugar, need sugar,
    yes, add sugar. So you keep on doing this until you don't need sugar anymore. So, that's
    again a loop. So, so, you might be thinking that why we are writing this add sugar and
    this boil water to writer to this this why we are really indenting this that style of
    pseudocode to just display that this is inside this this is this particular statement or
    set of statements are called the body of the loop and this end Oil should be here in this
    alignment here in this line and so, there is a there is a bug in this slide this should
    be
    here okay once this condition is false sugar needed no then you can exit this loop and
    you go here while milk needed yes add milk, check again milk needed yes add milk milk
    needed yes add milk. Once this condition becomes false milk needed no then you can exit this
    loop, you can just go to here. While latest here need to steer steer D need to steer yes
    sturdy he was there yesterday, once this condition is false get out and your tea is ready Do
    whatever you want to do. This example was so simple, but it expresses a very powerful
    tool in in the pseudocode as well as in flowcharts. And that tool is sometimes called loop which
    is there to repeat a particular procedure whatever procedure you want to repeat again
    and again to until there is a particular condition that is met that is loop loop is there. So,
    the The purpose of this slide is was just to just to make you make you convinced and
    make you comfortable with the pseudocode and flowchart we will not be talking about flowcharts
    any further from here on we will we will be just talking about pseudocode in just one
    or two more videos. And then we will be directly going towards from we will be we will be comfortable
    enough with pseudocode for solving certain kinds of problems that we will then eventually
    be moving from pseudocode to actual Python code. And and I bet you I'm going to tell
    you that the pseudocode in the next video I'm going to explain that will be very, very
    easily will be converted to the actual exact Python code. So in the next video, we are
    going to actually solve a problem of finding out minimum value from a list of values, sometimes
    called the searching problem, we're going to solve it by first using pseudocode. And
    then in a later video, we will see how to write the actual Python code for that problem.
    So hope to see you in the next video. Okay, let's dive into real problem. Let's say you're
    given, you're given a list of numbers, let's say, let's say l is some list. with numbers,
    let's say we define list by these, these square brackets, let's say the list contains 23.
    Let's say that's a value minus four, that value is zero, that's a value 73. That's a
    value, and maybe maybe minus 10. That's a value, maybe 13. That's a value. So let's
    just take an example that we have 123456 values in a list. So and that list is basically we
    took the list here as L and we just describe that let's say the list is declared by or
    expressed by the square brackets, and the elements of the list, they are separated by
    comma. That is just our convention for this kind of problem for this problem just for
    this code. And And I'm not talking about any particular programming language yet. This
    is just a list of numbers. And let's say we want a procedure that finds out the minimum
    value of any list. Well, first of all, why this problem has multiple instances. Well,
    we need to come up with a solution that works for any list for example, if the list is if
    the list has these six values, then the procedure should find out the minimum In this list,
    the minimum value in this list out of all the values is minus 10.
    Because minus 10 is smaller than every other value. 23 is bigger minus four is smaller
    than 23. Zero is bigger than minus four, because the, the value with negative sign, it is smaller
    with the value of a positive sign. But if you have two values with negative signs, the
    value with a bigger number, in terms of magnitude is actually smaller in negative sense. So
    if you compare minus four and minus 10 minus 10 is smaller. In minus in minus domain, in
    positive domain, the result is different. So I was talking about why this problem has
    multiple instances, why you need a general solution for that, that's less just go and
    find out the minimum that is minus 10. Go home happy? Well, we need a solution that
    works for another list. Another list with different numbers. And maybe different number
    of numbers. Maybe in this list, we have six numbers, another list may have 74 numbers,
    another list may have 1 trillion numbers, we want to come up with a procedure that always
    finds out the minimum value in that list. Obviously, the minimum value may repeat, I
    mean, the minimum value may occur more than once in a list. So what is a minimum value
    rather than knowing how many times that occur, what is the minimum value, that's a problem
    finding out a minimum value, and we want to find out, we want to come up with a procedure
    that finds out the minimum value, regardless of the list, whatever the list is, this procedure
    should actually return or end up finding out the minimum value. So, in this particular
    case, again, for this particular example, the minimum value is minus 10. And we will
    take example of this list, and we will see how to code a procedure for that. So but but
    before starting this procedure, what kind of things we really need to to, to write a
    pseudocode. For this kind of problem, we may start by writing that program, like in the
    previous video, program name as search. And then we take input or input list, then we
    take input, the number of values in the list the total number of values, and then we move
    on as as we want to move on. But writing out a procedure in terms of pseudocode, it is
    always good to to avoid these input statements inside the pseudocode. And always supply whatever
    whatever needed, always supply the instance, from outside and assume that the instance
    is supplied and then just work on that instance. Rather than reading the instance. Rather than
    taking the values of instance, a particular instance from inside the code, it is always
    a good practice to, to, to supply the instance from outside, so supply the list from somewhere,
    and this n is really the size of the list. In this particular case, let's say if this
    is the list, then that list will be there, supplied from somewhere, but we'll see how
    to supply that. And this n value here, in this particular case, the N value is six the
    total number of values in the list 12345, and six, these are six values. So it is a
    good practice to rather than writing program and then this, just write the name of the
    problem you're going to solve in this particular case the name is search minimum from list.
    And then this particular we are talking about this list l with total number of elements
    as n whatever the values inside the L is we do not know and and this n may take different
    values, l can be different, this n can be different for different instances. But it
    is not a good practice to take input from inside here. Then, one more convention is
    that, let's say list of two represents the second element in the list. In this particular
    case, L of two is basically L of two is basically the second element in the list, which is minus
    four, L of let's say three is the third element in this list, which is a zero, and so on.
    So let's let's take a convention, that whenever we want to access the elements of the lists,
    whatever whenever you want to read the elements from the list, we will read the element number
    by giving the element number here let's say whatever the if we write L of AI, that means
    it means the ayat element of the list.
    So, first we take a variable, we are assuming here that the list is supplied to us the total
    number of elements in the list is supplied to us. So we first take the minimum value,
    we, which we really want to compute the minimum value we want to compute, but any list can
    be supplied in this procedure. So what's the procedure, the minimum value that we want
    to compute, we just consider the very first value of the list in this case, the very first
    value is 23, we consider that is the minimum value. Obviously, that is wrong, this is not
    minimum value, minimum value may be somewhere else, or maybe this one may be somewhere else,
    but we are not sure that the first value in the list is the minimum value. But let, let's
    just hold on for a moment and move on. Let's say the minimum value is this here, this is
    called the assignment assignment. This min value is a placeholder or a variable, and
    I have assigned this value l one to it. Now, from here onwards, the min value will be will
    be will be having a value which is 23. In this particular case, okay, so min value is
    this, which is 23. Now, let's declare, let's declare another variable, which is called
    counter, we may need this counter. And let's declare this with two, why we are declaring
    this with two it will become clear later on. So now we so min Valley right now, for this
    particular list, the min value takes the value 23. So and counter takes the value two, these
    are two things for these two variables. Now, we apply a loop while counter is smaller than
    n smaller equal to n. Remember the value of n for this particular example is six, and
    counter here is two. So because counter has value two, while two is less than or equal
    to six, first check whether this condition is true or false, because if this condition
    is true, then you will go to the body of the loop, then this whole box will execute. If
    this condition becomes false, then you will exit the loop and we'll go out. So now counter
    is to the so two is smaller or equal to six. true false. That is true. So the condition
    is to two is indeed smaller than or equal to six, that is true. So we will go inside
    to the box and see what happens. Then what we will do, we will pick and pick a value
    from at the index counter. Right now the counter has value to L off counter means pick the
    value, because the counter has value to pick the second value, which is minus four and
    pick that value minus four from the list, pick that value and copy that value or assign
    that value to a variable v. That's a new variable we maybe needed somewhere okay. Previously
    the min value which is a variable, it was containing the very first value which is 23.
    Now we have picked the second value the counter value is two. So we have picked the second
    value from the list, which is minus four. Now we compare if the value now which is minus
    four is that value smaller than our minimum value. So far, the minimum value so far is
    is 23. So minus four is smaller than 23. Yes, the condition is true, if the condition is
    true, we will go into this block, otherwise we will go into this block. So right now the
    condition is true. So we will go in this block and minimum value will just be replaced by
    the new value. And the new value right now is minus four. So because a minus four is
    smaller than 23, so we are here in this body, the if condition becomes true, you're in this
    body, and the minimum value becomes whatever the value is in V and right for this example,
    the value in V is minus four. Okay? So if if if you go into the if condition, then you're
    not going into the else part, either you're going to F part or in the else part one of
    them. Okay, so then we move back Oh, there's a bug here we need to add the counter. We
    need to increment the counter here after after this. Before this. There is another statement
    increment the counter. increment counter. That's another statement increment counter.
    So Now increment the counter after this if part increment the counter, and the counter
    will become three. Now, we will repeat the procedure and check three is smaller than
    six, yes, we will go inside, and we will pick now the counter value is three, we will go
    and pick the third entry. And now the third entry will be in V, the V will now contain
    zero. Previously it contained minus four now it will contain zero min value is containing
    minus four now, so zero is smaller than minus four, no, if zero is smaller than minus four,
    then do this. But zero is not smaller than minus four, then go to the else part. And
    as far as just saying just go on do nothing, I mean don't do anything. So when you're here
    don't do anything except if condition increment the counter again. Now, you increment the
    counter the counter value will become four and the value add for is 73. First of all
    check for is smaller equal to six Yes, we will contain the value at index four which
    is 7373 is smaller than minus four no do nothing and given the counter check the if condition
    check the while condition now counter will be five five is smaller or equal to six Yes,
    pick the fifth entry because country's fifth the fifth entry is minus 10
    minus 10 is smaller than minus four yes okay. Replace min value with the new value. Now
    the min value will contain minus 10 okay because if has executed else will not execute, you
    exit the if condition and then you increment the counter the counter will become six. Now
    six is smaller equal to six Yes, because six is equal to six hence the condition is true.
    Now, you go and pick the sixth entry which is 13. Check 13 is smaller than minus 10 because
    min value is containing minus 10. So far, no that is false go to else condition, the
    two else part just go on to nothing, increment the counter, now the counter will become seven
    and you go back and check the condition seven is smaller equal to six false exit the loop.
    Okay, exit the loop, go to this condition, go to this statement. Now Now you're out of
    the loop and return the min value. And see the min value here is containing the actual
    min value which is minus 10. So that's how we search the minimum, this return is also
    a keyword. So which means if we if we just if we just if we just use that function, if
    we if we just use that pseudocode with if we just use that pseudocode for this different
    kind of lists with with its sizes, whatever the list, this is this was just one example
    if we chain the list, the procedure will work one one bug in in the code was the increment
    counter statement was not there, it should be there after the end F and before this end
    while here. So this that was the pseudocode of searching a minimum. In the next video
    we are going to use this pseudocode and we will we will see how to rearrange the values
    of a list or sorting the values of lists such that all the values that are smaller they
    become earlier than the bigger values. And the problem is called sorting. So in the in
    the next video we are going to talk about one more problem, very famous problem called
    the sorting problem. And after that problem, we will be going towards Python. Because after
    that problem, you will be having a fairly good idea how to solve a problem how to write
    a pseudocode for a problem. And the way we are writing the pseudocode is very close to
    the actual Python code which will become so clear to you. So hope to see you in the next
    video. Okay, in the last video we talked about we talked about this how to find out minimum
    value from a list of values. And we came up with an algorithm with name search men from
    list. Here we have just made a little modification that rather than just returning the minimum
    value, we are also returning the position of the minimum value in the list. So for example,
    if the list is 17024, let's say in nine letter that's our list. There are seven numbers in
    the list, the minimum value is zero. so the value the minimum value itself is zero, but
    that appears in position three. So when when this procedure will end, the min value will
    contain zero and the ID x which is the position at which the value the minimum value was achieved
    that will contain three So, not only we are not only we are finding out the minimum value,
    but also we are finding out the position of the minimum value.
    This procedure, our pseudocode actually describes a very simple, very simple concept, you consider
    the very first value as a minimum value and the very first position as a position of the
    minimum value, and then traverse the list element by element and, and see if you find
    any value that is smaller than the minimum value so far, if that is found, then replace
    your minimum value with the new minimum value and update your position number. And then
    keep on moving till the end of the list. So, so that's what, that's the concept behind
    the behind this algorithm searching minimum from the list. And to traverse the list we
    use this loop while loop. So next we solve a problem called sorting problem very, very
    famous problem in computer science. So the problem really is let's say we have a list,
    let's say 14035. And seven, let's say and the sorted order the ascending sorted order
    is the order in which the list is presented so that the minimum value occurs first, then
    the second minimum, then the third minimum, and so on. So the sorted order for this particular
    list will be this, so this is the result, this should be the result of this sorting
    procedure. So let's see how can we solve this problem, we named this algorithm as sorted
    list and sorted list contains this L. In this particular case, the L is simply this. And
    this n is the size of the list. In this particular case, the size of the list is six, so six,
    and right now l two is empty. So although we have to populate l two, but right now it
    is empty. And counter again, we initialize the counter with one. And as as long as the
    Conqueror is smaller than six, we keep on we keep on moving inside this, this block,
    that's the that's the body of the loop. So what we do is we pass the list and the size
    of the list. And we use the previous algorithm to find out the minimum from the list. So
    the minimum from the list will be found as zero and its position will be found as three.
    So min value will contain zero, and Id x will contain three, then what we do, we pick this
    minimum value and insert in L two l two was initially empty. So we insert in L two, we
    insert the minimum value, which is zero so far. And then just in the original list l
    we delete the value at the position index. So for example, the index position is three,
    so we delete this particular value. So what we really do is we delete this value, we delete
    this particular value. And the list now becomes with size 1234 and five, so what we do is
    we decrement the size with with one and then we move on now the country is one again, the
    N value rather than six. Now the N value is five, so one is smaller than five, but the
    list has no zero now in it because it was deleted, we searched the minimum again, and
    we insert the minimum in the list. Now the minimum will be one in the new list. And we
    delete that value from the list. And we decrement the size we keep on moving, eventually the
    list l two will be populated like so. And once. And once this value of n becomes negative,
    which is minus one with we will exit the loop and we will return the sorted list. But see
    how this sorting procedure actually uses the algorithm that we that we defined in in RPB
    previous video.
    I'm not talking about that this kind of sorting algorithm is the most famous sorting algorithm.
    There are efficient algorithms very great kind of algorithms for sorting. But the idea
    here is not to actually teach sorting the idea here to actually come up with the pseudocode
    for this sorting problem. And also to show you how you can use the pseudocode how you
    can use existing pseudo cores as as instructions in in other pseudo codes. So that's all about
    problem solving. If you really understand the selection sort and all that procedure
    really well, you're actually very good in problem solving, at least the problem solving
    is that we encounter in the logic that we need to solve different kinds of problems
    in computer science. In the next video, I'm going to actually convert these pseudo codes
    to Python codes. What do you need? Doo doo doo, right this sortlist procedure in actual
    python programming language, and how will you change the search minimum from list in
    actual python programming language, we will see the Python details bit by bit in detail,
    starting from right zero and ending at the very high details of Python. So, in the next
    video, I will just be showing you how to convert this code. But when we will start learning
    Python, we will start from zero and we will see each and everything of, of Python in in
    detail. So don't worry. In the next video, if you see, I mean, things like lengthy chords
    in a very beginning, these are just because we have arrived at a pseudo code. It is very,
    I'm just want to show you how the pseudo codes which are very across expressible, how they
    can be easily converted to Python programming, just to show you the power of and simplicity
    of Python programming language. So in the next video, I'll be converting these pseudo
    codes to Python code actual programming code. So hope to see you in the in the next video.
    Okay, in the previous video, we just get a flavor of problem solving by using this selection
    sort called the sorting procedure. The idea was just to use this procedure to solve this
    kind of problem. And we saw in detail, not in that detail, we just just brushed up but
    we saw how to write a pseudocode for solving a problem of sorting, which requires actually
    a list to be sorting in ascending order. For example, in this video, I'm going to convert
    first this code search minimum from list, you see that code, you know that code completely,
    we're first going to convert that code in Python code, and then we will convert this
    code in Python code. So see step by step, what changes are there. First of all, in Python
    that we will see in detail. When you define procedures, different kinds of procedures,
    they are called functions in Python. And rather than writing this, we have to write a def
    statement before it and then whatever name we want to write out, the rest of the thing
    stays the same, except at the very end, we have to write a colon. That's the syntax of
    Python. So the changes from here to here is a def statement, which defines that is used
    for defining def for define. And then at the end, we write a colon. Next thing that we
    will see in detail, don't worry if you
    if you're if you just see that why we're messing up with lips. So early, we will see that things
    in detail. But just to compare the in pseudocode. Normally the lists are indexed the indexes
    of the list start from one. But in Python programming language, the first index of the
    list usually starts from zero. So they are the minimum value was the first value of the
    list here, the first value is actually the index and Python is zero, rest of the things
    are same, you declare the variable as in pseudocode. The same goes exactly in Python. They're the
    because the index was one. And so the counter was one more than whatever the index was.
    Here, the counter is simply one, we need to right here ID x ID x equals to zero that we
    just missed. In the previous the ID x is one, so here the ID x is zero, that's okay. Okay,
    then next, we write while counter is less or equal to n. Same thing while counter is
    less or equal to n here. So here we just write the, the colon at the end, we might have written
    this equal sign here, this equal sign, we just missed the equal sign the equal sign
    is there. So now, but see that see the difference here, the violet goes that way, here we have
    a colon at the end, rest of the things are exactly the same. Now, v is equal to L counter
    v is equal to L counter the same thing if v is less than the minimum value, same thing
    if v is less than the minimum value in the pseudocode. Python is exactly the same. Just
    see the colon at the end, we have colon at the end of the while statement, we have colon
    at the end of the definition, we have colon at the end of the if statement. The other
    statement in pseudocode. In Python exactly the same. Now, in pseudocode, we have l statement.
    In Python, we have l statement. If we want to write an else statement, we have write
    a colon at the end of that. Then in Python in pseudocode, we have a past statement Python
    in our past statement, same things in pseudocode. We have n def, just to describe that this
    f ends. In Python, everything is described by the indentation style. So if this indentation
    goes on, if we have If you're here, then this is goes if this if goes out, so we need not
    write ends every day. Similarly, the vile body has this indentation style, this is all
    the while body, whatever that is, that is earlier than this is not in the wild body.
    So, rather than writing the tokens and while and if the Python handles everything using
    indentation, so no need of end if no need of end while Oh, we haven't, right, we haven't
    written a counter here. So we have to write a counter plus plus here, so counter. So the
    same statement, we missed this statement in the Python code. So the same statement, exactly
    the same statement goes here. That's it. The rest of the story is same, we do not need
    an end search here. The goal here is to show that the pseudocode is, I mean, the way you
    write the pseudo codes, they are they're highly,
    they highly resemble with the actual code in Python, Python is that expressive Python
    is very, very high level language. I mean, the way the you the way you think the problem
    in the pseudocode, the actual Python code is much similar to it. So learning the Python
    is very, very simple. The simplicity of Python is really a great property of Python. And
    that's one big reason of popularity of, of Python. Now the return statement is same and
    everything is same, then we move toward the sorting. Again, we have sortlist, we have
    to write the Define def define, and then we have this colon out there, we have to write
    the colon there, then let's do is defined like empty, it's empty in Python as well.
    Counter starts from zero, because they are the list starts from index one. In Python,
    the list starts from zero, so we are at zero, while same as this one. Here we have this
    colon, maybe, maybe an equal sign, maybe an equal sign should appear here. I guess we
    are missing an equal sign. But either way, the code is more or less the same rest this
    statement exactly same as this statement, we have insert in L two, here, we write a
    band append function, I'm in Python, here with ID lead this in Python, we have a Dell
    statement, rest of the story is exactly same. So you see converting pseudocode to Python
    code is, is way more easier. This is this is not a this is not a formal introduction
    to Python. I mean, the the goal here in this video in these kind of session videos is just
    to introduce you with problem solving. But I I found this, I mean, I found this beneficial
    to show you that the pseudocode actually resembles to the actual Python code a lot, although
    we will be dealing with variables lists, while loops, if conditions, all these kind of stuff
    in them in a in a big and huge detail. When we in the upcoming videos, when we will introduce
    the Python syntax and variables and all that kind of stuff. Actually, you will be mastering
    each and everything in Python. And, and further, you may not write these lengthy chords to
    do stuff in Python, I mean, the whole dad thing is just you write l dot sort and you're
    done. I mean, you need not write a lot of lines of codes in Python. Here, I just here
    I just showed you that if you have a procedure, you can, if you have a pseudocode it looks
    like much like the same as Python, which, which actually tells you the expressive power
    of Python and simplicity of Python, and how it is closer to what you think. But the actual
    problem solving
    in Python does not require so many lines of codes, I mean, there are so many functions,
    so many powerful procedures. For those you just write one line and a huge amount of work
    is done for you. And there are very good one liners for Python I mean in for for for for
    programming in Python, you did not write a lot of lines of code to do some stuff. I mean
    a few lines of code even a single line of code does a lot for you. And for that you
    need to know the features of Python the feature of the features and the different kinds of
    syntax and features and libraries and the packages and what what is available with Python.
    I tell you almost each and everything is available just you need to know what is available. Once
    you know the what what what what are the things that are available. You need not to write
    lengthy codes you need now to build a lot of logic on yourself. Things are prepared,
    they're waiting for you, you just have to figure them out what are these things to do
    what what kind of features are there in Python, if you know that you are done. So you need
    not to be writing these kinds of codes and lengthy kind of codes. Although knowing that
    all knowing that is a is a is a huge advantage, but doing a bigger and bigger and bigger stuff.
    Python will give you a lot of features a lot of functionality that you need not to go into,
    and you need not write a lot of code for it. And that's the second power of Python. One
    is simplicity. Second, it gives you a lot of features a lot of functionality, a lot
    of built in stuff ready for you, you want to do something, it will be probably there
    in Python, you need to know where it is. And for that we have whole future series on Python
    to know Python each and every step in Python, and to know important packages in Python.
    Because knowing important packages and knowing how to code in Python will save a lot of time
    for you. So spending some time on learning Python will be saving a lot of your time.
    To solve the actual pure problem. Whatever problems you're doing, you're going to solve.
    And Python is a real programming language granting programming language, knowing this
    language is almost enough. So hope to see you in in the next videos where we will start
    Python from exactly zero. And we will see each and everything of Python in detail. Hope
    to see you in the next video. If you're new to data science, you may stuck in choosing
    the best language for data science. And in this video, I'm going to I'm going to talk
    about Python, which is the greatest language so far for data science. To explain the features
    of Python, let me first go back to a little bit history of Python from where it started.
    It basically starts in 1980s. It was introduced first in 1980s. But with constant improvements
    and a lot of bug fixes. It was officially launched in 1989. Nine years later. It was
    created by Guido van Rossum and it is open source which means it is accessible to everyone.
    Even though it's open source. It can be used for commercial purpose. The main goal of Python
    was to keep the code easier to use and understand. Its huge library enables data scientists to
    work faster with the ready to use tools it is dynamically typed. So the variables that
    you are defined that you are defining that they are defined automatically, you need not
    to set the type whatever the contents in bring in, the type will be defined automatically.
    It is more readable and uses lesser code to perform the same task as compared to other
    programming languages. It is flexible, portable, and can run on any platform easily. It is
    scalable, and can be integrated with other third party software easy. Python programming
    is easy to use, and has a simple and fast learning curve. new data scientist can easily
    understand Python, but it's easy to use syntax and better readability. So so that's what
    this point is basically it's it's really a beginner friendly if you if you're new to
    programming. Well, Python offers you a very easy environment to go on. It also provides
    plenty of data processing tools that help in better handling the data. Python is important
    for data scientists, because it provides a vast variety of applications used in data
    science, it also provides more flexibility in the field of machine learning and deep
    learning.
    It has, it has a lot of packages like TensorFlow, Kara's tiano. That is helping data scientists
    to develop specifically the trending deep learning algorithms very, very quickly. So
    basically, the sport, the sport of machine learning and deep learning is huge in Python.
    That's huge. As, as is the case with many other programming languages? It's available
    libraries that lead to Python success around around 72,000 available packages. In Python
    package index, sometimes called by pi, Python. Why? Python package index by by around 72,000
    packages are available and they are good Constantly. So huge number of packages mature packages
    are available. It is free open source and consequently, any Can anyone can write a library
    package to extend its functionality. Data Science has become an early beneficiary of
    these particularly ponders The Big Daddy of all of them. The other great thing about Python
    is there are millions of users who are happy to offer advice or suggestions. When you get
    stuck in something, chances are someone else has been stuck there first. So a lot of community
    is there, a lot of packages are there, it's open source it it's easy to use, it's easy
    to learn. It's simple, it's readable, more close to human language, it's high level language,
    you code less you do more, I mean, you write a very few lines of codes, and you achieve
    a lot of work. So, I mean, I've spoken a lot of verbs here, too, too. I mean, explain that
    Python really is best suited language for data science. But let me let me introduce
    you some statistics about Python, the popularity of Python with respect to big with respect
    to its use, and with respect to the job opportunities that are there in Python. So for example,
    if you see this chart, in the ranking of top 10, languages, Python stays at the top. So
    that's the latest statistic, collected in 2019, February 2019. And out of the out of
    the total share of the languages, I mean, around 26%, just goes for Python, and the
    trend is moving up, which means the people are more interested in Python, I mean, the
    trend of using Python is getting larger and larger, as compared to several other languages
    like Java, JavaScript, C, sharp, bhB, C, our objective c, swift and MATLAB. I mean, many
    of them are used for data science, but Python stays at the top. I mean, this is that popular
    language. And further, if you see, for example, the job opportunities in Python so so that
    says, I'm in a different companies like Facebook, Julia, and I'm in Google and several different
    companies. This actually graph shows from 2014 onwards, that the job opportunities and
    job postings are in different languages are at what amount, and you can see the graph
    of Python, although starting a bit low, but then stays up and stays up, which means the
    80 if you see the numbers 85% of the total jobs, there are just for Python. And not only,
    I mean, Python is not just for data science, it's a general purpose programming language,
    it's open source, it can be it can be used to perform any kind of task for embedded programming
    for, uh, for for posting, I mean, codes or embedding code on Raspberry Pi for web development
    and whatnot. You can you can, you can do the desktop development on it, you can use the
    web developer knowledge you can use the data science, I mean, I mean, this is general purpose
    programming language. In other disciplines do it is performing very well. But data science
    for data science, it is almost the default language today.
    So, I mean, if you're going to learn data science, really, we need Python. I mean, Python
    really is the choice, the default choice, and we need it. And in this particular course,
    we are going to, we are going to introduce Python to you with all aspects, I mean, we
    will start from the very beginning level. And we will gradually move towards the very
    advanced programming in Python, including the introduction to the data science packages,
    like pandas and matplotlib, for visualizations, and NumPy, for handling numeric data and stuff
    like so. So, in this particular course, we are really going to teach you Python, and
    we are not assuming you have any programming experience before. So and this is one plus
    of Python. I mean, whether you're an engineer, you're coming from health sciences, you're
    coming from biology, you're coming from arts, humanities, or from wherever. Python is something
    that is very easy to get hands on. So if you're not assuming that you have any programming
    background, you have any data science background nothing. So we will start from the zero and
    And we will gradually move to 200. So, and including the introduction to the data science
    packages. So Python is the best, it is a default. If you're going to work in data science, Python
    is the default. And we are going to, we're going to introduce you Python from the very
    beginning to the very professional. So hope to see you in this course. Okay, before actually
    discussing the best ID for Python, and particularly for data science, let's first discuss what
    an ID he is, as you start your coding journey, many of you prefer coding in a text editor
    maybe like notepad plus plus, where you write the code and then open a terminal window to
    execute your code. When there is an error detected in your code, you switch back to
    the text editor, correct your errors, typos and run the code again in the terminal, everything
    is fine. Typically, for large scale problems, however, you not only have to code but you
    also need to make sure your code works in all scenarios, which means you also need a
    testing module. Many times you have multiple coding and testing files, and switching between
    editor and terminal often becomes both confusing and efficient. So, an environment is needed,
    where you can write you can run and play with your code all at one place. So the one that
    provides you with the capability of not just coding, not just writing the code, but but
    also testing your code, running your code highlighting your syntax, bracket matching,
    auto completion, debugging your code, code suggestions, and and many more features. That
    is called an ID II or integrated development environment. Now, there are several ID is
    for different languages for for Python, there are several ideas for example, Jupyter Notebook
    is an ID IE by charm is an ID IE spider is an IP ID and thought cannot be whim atom and
    there are a lot more there are several of them. Now the question is for data science,
    in particular, what Id E is is the best or are what people suggest to be the best. So
    before actually showing you the statistics that which one is the best before actually
    showing you the actual numbers, the statistical numbers that shows which one is better, what
    are the other let me just go through a few of them few of it ease and their features
    and stuff. And then we will move to move to statistics and some numbers that will show
    that which one is better over the other. So let me start with with this Jupyter Notebook.
    For the past couple of years Jupyter Notebook has been gaining a lot of popularity in terms
    of coding and debugging. notebooks have been redefining the concepts of an ID E and are
    adding more and more features on to it. Jupiter was introduced in 2014 after its predecessor
    ipython and from that date, it is really considered to be a bless in the coding community.
    Jupiter stands for I'm in some people say Jupiter stand for Giulia Python r but that
    I come in that acronym does not mean just this. I mean Jupyter Notebook today is supporting
    more than Giulia, Python and R and by the way, this Giulia Python, R and R all these
    are open source languages for and they are best suited for data science. This Jupyter
    Notebook, it has markdown editor. It allows you to write HTML code, it allows you to write
    latex in it. I'm in a lot more. Further this Jupyter Notebook. It's a web application based
    server client structure, which is easy to use and allows you to create, analyze, and
    manipulate documents. And all these documents are in the form of notebooks. Since it's a
    web web interface, it can integrate with many of the existing web libraries. For example,
    for data visualization. Jupiter has so many functionalities you can write formula using
    labtech run a Python code and visualization. For example, a raw audio signal using matplotlib
    plotting library, all in the same notebook. Jupyter Notebook is not just an idea he but
    it's widely used and an educational tool for presentation and even for writing blogs. You
    can export your notebook from iPython Notebook formats to PDF or to HTML or even to.py, which
    is the Python file. The user interface of Jupiter makes it a favorite tool, especially
    amongst the data science community. And one plus of this Jupiter is, it's it's very quick
    to start, I mean, very easy and very quick to start, I mean, not much rocket science
    to write your first goal, you want to write your HelloWorld it's very, very quick. And
    you're better to go and do that. By charm, if I discuss pi charm, however, if I discuss
    some of its properties, and let me just discuss, first that the pipe the PI charm is by the
    company JetBrains. And if you have never used japin JetBrains other IDs like Java ID, then
    running your first code successfully can eat up a little bit of your time, actually, a
    large amount of your time maybe such as I mean, setting an interpreter by charm. By
    charm, however, is, is much better for, for working with multiple scripts, handling multiple
    files and linking them together and huge large scale coding products. The good thing about
    Python is it supports Anaconda. And as a result, all the packages that fall under Anaconda
    are supported by char pi charm as well. And those packages in including NumPy, Sai, pi
    matplotlib, and so on. Just like other IDE ease pi charm has a powerful debugger. With
    a graphical interface. It offers jet integration, it has skills, shell terminal and worryin
    control system. Python, it is customizable, which allows you to choose between different
    themes, color schemes, and key binding and whatnot. Additionally, Python lets you add
    plugins for non pythonic files. And these plugins take care of indentation highlighting
    the errors and keywords just on the fly. So Python is also providing I mean, a huge support
    for coding Python. But, I mean, the one bad thing about Python, which is not that bad,
    but one bad thing is it is memory intensive. It eats up a lot of memory. It's a heavy thing.
    And secondly, I mean getting getting getting started with PI charm is not that quick. I
    mean, it takes a lot of time to just go with that. Spider however, is a lightweight, open
    source ID Oh by the way, this by but this by charm is is is not I mean it has Professional
    Edition and and Community Edition and it does not open source completely. Spider however,
    is a lightweight open source, ie that comes pre installed with Anaconda. And it was built
    mainly for data science practitioners and engineers. Its look and feel is much like
    MATLAB. So if you're a MATLAB programmer, if you've used MATLAB before, you switch to
    Spyder and you get a mean much look and feel the same cannot be by the way the unthought
    cannot be also has roughly the same look and feel as MATLAB
    So, but spider was built for data science community, it is integrated with essential
    data centric libraries like NumPy, Sai, pi, matplotlib, pandas, ipython, and whatnot.
    The built in capabilities can be extended further by plugins and API's Spyder contains
    features like text editor with syntax highlighting code completion, static code analysis, debugging
    variable exploring, it also has profiler that recursively determines the runtime and number
    of calls for every function and methods call in a file. And I mean, there's no thought
    cannot be there is a vendor's atom there are a whole lot of it is just for Python language.
    But But the question really is being a data scientist, which one is which one should you
    choose being a beginner? which one should you choose? Even even for professionals, if
    you want to stay in data science, which ID he will you prefer over the other? I mean,
    there are so many of them. I have just described three or four of them. So let's see some stats
    based on popularity of different IDs for data science, and then decide which one is better
    over the other. So for example, this data this this analysis, that the chart I'm showing
    here, this analysis by was was done by Katie nuggets and The link for that and it shows
    that the most popular Python editors till December 2018 and you can see that the Jupiter
    is at the top, the second is pi charm, then spider then Visual Studio code and sublime
    tags, then add on atom women there are so many others, but Jupiter is at the top and
    this is for I mean, these all are listed with respect to the data science community. So
    in the data science community which Python ID he is best over the other and, and Jupiter
    Jupiter is at the top I mean it is it is way out. And one reason to this is its simplicity.
    It's it's supporting to so many different formats. It's it makes an interactive document
    it makes it makes a web page that is interactive, you can just change the code you can make
    another web page and so on. You can you can run it on a local system you can run it an
    online survey system and whatnot I mean it has so much flexibility and very quick start
    and easy to use. If you for example see the popularity of Python IDs with respect to the
    employment then then you can see overall the the Jupiter has been a winner as compared
    to pi charm spider also your code and sublime if you see company or self employed still
    the Jupiter is V out it has been if you see for in a student perspective, Jupiter is the
    choice. If you go to academia or university, Jupiter is the choice if you are working with
    government or nonprofit Jupiter is the choice I'm in Jupiter is I mean Jupiter is kind of
    outlier it is it is staying at the top everywhere. Further if you if you analyze the popularity
    of Python, it is with respect regions for example, again, overall, Jupiter is a winner.
    If you see US or Canada Jupiter's most popular mostly used Europe, Jupiter is the winner
    Asia, Jupiter is the winner, America use Jupiter sevinor effect Africa and Middle East Jupiter,
    Australia, New Zealand Jupiter. I mean, these numbers are suggesting that Jupiter is is
    at the top, not just at the top. It's easy, I mean, and maybe that's one reason why Jupiter
    stands on the top for the data science. So these numbers and these all statistics suggest
    that we should use Jupyter Notebook for Python. And we will be doing that. In fact, for this
    particular course we'll be working on Jupiter for all kinds of coding. And in the in the
    next video, I will be just showing you how to install
    Jupiter environment how to install basically Python and how to run Jupiter for the first
    time from it. So I hope to see you in the next video. Okay, in this video, I will show
    you how to install Python. There are multiple ways of installing Python you can go to python.org
    and install Python from there I would recommend to use Anaconda distribution it has Python
    it has a lot of packages pre installed it has Jupyter Notebook as well. So installing
    through Anaconda is easier as well. So if for example if you are working on a Windows
    system you should download the executable for Windows we will be working with Python
    three rather than Python two. So you should be installing you should be downloading Python
    three point whatever the latest version is. Further if your system is 64 bit you should
    be installing 64 bit version otherwise you will be installing 32 bit version. So let's
    say you have downloaded the executable file for Windows then after the download you just
    from that xe file and follow the steps and you'll be able to install Anaconda once the
    Anaconda is installed then in the search bar you just type Anaconda prompt and the Anaconda
    prompt kind of symbol that my mouse is pointing at this will appear in front of you, you just
    run it you will see a command prompt like so. Then in that just type Jupyter Notebook
    and press enter and you will be having Jupiter running in front of you. Let me let me show
    you that on my on my system. How to do that. Let's see. For example, this is my search
    bar. Let me type and conda prompt so this is the Anaconda prompt. So if I click it,
    it runs then I just typed for example, Jupiter note book Then I just press enter. For the
    first time it will take some seconds to run. So let's wait for it. So yes, it runs and
    it will show you kind of browser in front of you. And that's what the Jupiter into interface
    is. We will see then how from this Jupiter how to write the code how to make the code
    files and stuff but that's how from Anaconda installing after installing Anaconda that's
    how you will launch the Jupiter. So this is that easy, no problem. Then, for example,
    you can install you can install Python if you're working on Linux and just download
    the version for Linux. And then rather than For example, let's say your your your file
    is downloaded in the Downloads folder then run this command bash and this.sh that's the
    file name. The installer prompts in order to continue installation process this I'm
    in these kinds of commands will will appear Press Enter to Continue then press Yes, and
    the installer will finish with the thanks message. After that, you just go to downloads
    folder and type Jupyter Notebook and the Jupyter Notebook. interface the browser based interface
    will appear in front of you. You can have if you're if you're working on Mac, you can
    you can in you can download the Anaconda distribution for Mac, then you'll find an anaconda Anaconda
    navigator, the launchpad you can launch that and then just click there's a Jupiter icon
    in front of you just press the Launch button and you'll be having your Jupiter running
    in front of you. So in this video, we just talked about how to install Python. If you
    install Python using Anaconda you will be having Jupyter Notebook as well. In the next
    video, we will see how to actually use that Jupyter Notebook interface for example, I
    work on Windows, so I'll be having this kind of interface although the interface looks
    like same because it's a browser based web based interface. In the next video, I will
    show you how to get comfortable with Jupiter and we will be also writing our first HelloWorld
    program in Python. So hope to see you in the next video. Okay, so in this video, I will
    show you
    how to write the first program in Python basically the HelloWorld program. Before that, in the
    previous video, I show you I showed you how to launch Jupyter Notebook. So once you launch
    Jupyter Notebook, whether you are working on Windows, whether you're working on Linux
    or Mac, whatever, when you will launch the Jupyter Notebook, you will see this web based
    interface. And here you are in the right corner you can see the button new, you just click
    it, you will select Python three, and you will see a beautiful interface in front of
    you that will allow you to go here, there are a lot of file edit view there are a lot
    of parents kernel and a lot of controls here we will see them as we move on. But this is
    how you this is this is what the coding environment is this is kind of editor as well as I mean
    this is complete, ie interface in front of you. So let's see this interface a little
    bit. Step by step at least the controls that that we need. First of all, you are seeing
    where my cursor is moving. That's the file name or the notebook name. You can change
    the notebook name or you can just write for example. Whatever the name of the notebook
    you want, for example, mastering by Thorne
    for
    beginners. Okay, so let's say that you're mastering Python, let's say let's say zero
    to hero, maybe. So let's say this is your filing, you just create that file and you'll
    see this mastering Python zero to hero that file is created with this file is renamed.
    Second. This is a cell in which you are going to type your code. The code, I mean, the two
    modes of writing is one is you can write the Python code. Another way is you can write
    the markdown. The markdown is important in in a way that if you want to describe your
    code, if you want to write other stuff other than Python code, you can use these markdown
    cells and they We will be helping you. For example, if I select this markdown, and I
    just select this markdown, and I type here, for example,
    this is by THON directorial. And then I press Shift Enter, it will appear as a heading.
    And a new cell will be graded down. This is also a cell. But this is a markdown cell.
    As you can see, now in this cell, that's a code cell, you can switch a cell from code
    to markdown by just pressing an escape key, when you press an escape key, you will see
    the color will change here, you can press Escape key, then if you press M, it will change
    to markdown. And if you press Y, it will change to a code cell. There are several I mean shortcuts
    that are available keyboard shortcuts, if you if you just see, if you go to help and
    see this keyboard shortcuts, there are several shortcuts that will be available in front
    of us. For example, if you press escape, and then press F, you can do the Find and Replace
    operation. And if you press enter, then that will go into Edit Edit Mode, if that's important,
    if you press Shift, enter, the cell will run and the new the cursor will go into the new
    cell. And there are a lot of controls you should be seeing most of them, I mean, getting
    a good grip on these controls will help you moving in this Jupyter Notebook very quickly.
    So for example, this is a Python tutorial that's a markdown cell, you can also create
    this, this cell also as a markdown cell. And then you can type here for example. This is
    our first program in Python. It there it is just started here, for example, and it just
    appears like like a description. And again, a new cell is created down and there you can
    write your code. So let's write the first Python code HelloWorld. So first of all, you
    will write Brent Brent command will allow you to print anything on the screen. brantas
    says double codes, starts ends. And in the double code, you write whatever you want to
    be printed on the screen, for example. Hello,
    world.
    And once you have written that code, just press Shift and enter, and this code will
    execute in front of you. So that's HelloWorld printed in front of you. And that's our first
    program, I mean, writing the very first program in Jupyter Notebook. is is that easy. Not
    only that, this Jupyter Notebook will be created, you can you can just I mean describe anything,
    you can write the headings, you can write HTML in it, you can write math, using lattic.
    And for example, let me let me write lattic, or mat in front of you just just let's say
    you're making a notebook that requires some mathematics in it. And it allows you to write
    mathematics as well. For example, A equals B plus C, Shift Enter, and that appears like
    a mathematical equation, not just this, you can write very complicated equations. I mean,
    and and, and this whole notebook will contain your descriptions in terms of HTML or latech,
    or descriptions, and code and all that mixed up, whatever. And at the end, you will, you
    can, you can just download this. You can just download this, this notebook, as if you want
    a PDF file PDF file. If you want a notebook file, it's an output file if you want to latech
    if you want just a Python file if you want slides, for example. I mean, you can download
    the same thing as slides. It will make slides for you. So there are a lot of ways of using
    this notebook. And that's a ready made document. I mean, you end coding, the document is ready
    for you. So this notebook is really, really powerful Jupyter Notebook and coding in it
    is not just the coding. I mean, it is Preparing a document. If you want to prepare a document,
    you want to describe anything you want to add images, and at the end of the day, it
    will be an HTML document for you. It can be shared on web. I mean, it's ready. Nothing
    we we want to further finish it. So that was our HelloWorld program in Python. We will
    continue to build this byte mastering Python zero to hero notebook, we will continue coding
    in that we will describe the headings we will write the markdown cells and all that stuff.
    And we will at the end of this course, you will be having one notebook with all kinds
    of descriptions and code in it. You can use that notebook afterwards, we will be building
    well one notebook, one complete notebook for Python. So that's about it. That's the hello
    world. In the next video, we will see how to what are what are the constructs in in
    Python, what are variables and other stuff. But before that, I also wanted to show that
    this notebook is an enhanced worryin are the upgraded version of ipython shell. And I also
    want to show you ipython shell as well. So in the next video, we will just see the ipython
    shell and we will see how can we how can we view Python as just as a calculator by using
    ipython shell. So hope to see you in the next video. Okay, so in this particular video,
    I'm going to show you the ipython shell just open up the Anaconda prompt as as before,
    like you want to open a Jupyter Notebook, then you just type here Jupyter Notebook.
    And you will be you will be in the in the notebook word Jupyter Notebook word. But if
    you just type in ipython and press enter, then a prompt is open for you in a colored
    way. And this is perfectly fine to write any kind of Python code in here. Actually, the
    Jupyter Notebook is more enhanced and more featured the use of ipython. Basically everything
    that I bought, that is there in ipython is there in Jupyter Notebook as well. But it
    has more features more documentation and stuff. So for example, if I just write a Python code
    here,
    hello world, let's say it will work in ipython shell as well. But remember, previously in
    in Jupyter Notebook, we type Shift Enter to run a particular command here, we just press
    enter and everything will work. If you want to clear the screen here, whatever the whatever
    we typed here, if you want to clear that, just press Ctrl l if you're on Windows Ctrl
    l will work on Windows. Now ipython is just like, you can use the Python in this particular
    shell just like a calculator, for example, you want to plus three, press enter, that's
    five, let's say it's nine multiplied by seven, the answer is 63. You can write a complicated
    statement as well, for example, 45 minus eight is static, or multiplication, static is achieved
    by multiplication is achieved by a static symbol seven. And then you can have this minus
    then divided by two and just press Enter. And that's the answer 16.0. If for example,
    by the way, I have just press the up arrow key and last command just appears. I have
    pressed up arrow key again. And the second last command appears. I press the up arrow
    key again and the third last command appears and now I'm pressing the down arrow keys.
    So for example this and you may have whatever the result is, you may have that multiplied
    by 10 and minus or or maybe plus plus 15. So the result is minus 145, and so on. So
    this Python ipython shell, you can write very complicated are almost I mean, the complete
    Python coding can be written in ipython shell. And you can use this shell just for a calculator.
    Now let let's see, for example, you you compute this result, let's say 45 minus 45 minus nine
    and let's say you compute this result, whatever the result is, and you save that result in
    a symbol, let me call that symbol as a variable. In here the variable is So let's say you save
    that in a, and then you have another variable, let's say B, and three static 45, or maybe
    three steric 2.6, that is saved in B. Now, you have you have done this particular calculation,
    you know that 45 minus nine is in a, the result is in a, and then you have this particular
    result that is in B. And now, you just want to add the two results together, and you want
    to print the
    what what normal calculators does not have the support of saving the results and reusing
    them. But here in Python, even if you just want to use the Python, just as a calculator,
    you can declare as many variables as you can and you can save the previous results, you
    can retrieve the previous results. And you can use the previous results, save new results
    and so on. These kind of symbols that are used to save the results, and then they can
    be just used afterwards, these are called variables. And our next video will be on variables,
    what are these variables, what are the types, what kind of variables the Python supports
    one way or the other, if you want to go beyond calculators, you need certain results to be
    saved and retrieved retrieved afterwards. And the variables are are the constructs the
    variables are the features that actually do that. So the calculator is fine, you can use
    this ipython shell just as a calculator. But if you want to do interesting programming,
    complicated programs, I mean, you want to achieve a task that involves much more calculations
    one way or the other, you have to save certain results in somewhere. And then you have to
    combine the results together because the longer problems in normally are broken up into smaller
    piece of problems. And each smaller problem has a result that should be saved somewhere
    and afterwards the several results they should be combined to achieve the result that we
    are after. So these variables are required if you are going to do some interesting or
    complicated calculations or computations. So you, by the way before, before having these
    Jupyter Notebooks spit out just the enhanced version of this ipython shell, the iPod ipython
    shell just people used to write a lot of Python programming just in ipython shell. And even
    even today is several people are writing their code complete code in ipython shell. But the
    the Jupyter Notebook is more enhanced for the enmore documented more, I mean, it has
    better interfaces and several features that are better than just using ipython shell.
    So you have seen this ipython shell, it's very powerful, great, everything is fine with
    it. But we will be using Jupyter notebooks, which are just the enhanced variants of this
    ipython for our upcoming coding. So the purpose of this video was just to was just to introduce
    you with ipython shell and just to tell you that you can use Python just as a calculator
    and even more than that, and in the next video, we will be introducing variables in Jupyter
    Notebook and we will see the Python or Python is really really much more powerful than just
    a calculator. So hope to see you in the next video. Okay, in this video, we will talk about
    variables and operators the operations that you can perform on on variables. A variable
    in a very layman term is basically a symbol that stores some data that can be used later
    on. So for example, this x is a symbol corrector or a symbol y is a symbol x y is a symbol
    normally, and these are called names of the variables. For example, this is a variable
    name x, y is a variable name y, x y is a variable name itself. Now, these variables, they can
    store different kinds of data, I mean, whenever you want a particular data to be used again
    and again, it is better to save that data or label that data by a symbol by a descriptive
    name so that you can retrieve that team retrieve that data by using that label or symbol. So
    one way or the other. This this variable actually is a description of the data that you want
    to use our store and you want to use later on in your program. Different types of data
    are there, for example, the integer type data.
    For example, if the data you want to store is integer type, it's a number And the number
    is just the integer number it does not have a decimal point expansion that is a type of
    data and that can be stored in a variable in that in that case, the variable type itself
    will be integer, you need not to specify the type of variable when you are storing the
    data to it the storing data to a variable is sometimes called assigning data to a variable
    or assignment. For example, if your variable is x, and you are assigning a value let's
    say two, then two is integer value its integer it does not have a decimal expansion and when
    to is assigned to x, based on the content to that to basically is an integer type value,
    automatically this the type of x is set to be integer. And that is sometimes called the
    dynamically typed Python is dynamically typed language or dynamic typing, you need not to
    specify the type of the variable the contents that you are assigning to a variable, they
    will define the type of the variable on the fly. And the assignment for example, in here
    I'm storing two insight x and next time if I want to print for example, what is there
    in x the the print value will be two. Now, this kind of symbol is hot right there is
    no keyboard symbol that looks like so, so rather than writing this symbol for assignment,
    normally an equal sign symbol is used for assignment for example, x is equal to two
    that means two is assigned in x five is equal five is equal to five means five is assigned
    in y 7.2 equal x y equals 7.2x y is completely a new variable, it has nothing to do with
    x or y. And it is handy sometimes to to to suggest the name of the variables that are
    too descriptive that are very, very descriptive to increase the readability and management
    of the code, because later on you will you will be seeing when you will be working in
    data science and other stuff. The programs that you will be writing might not be very
    short programs, they might be lengthy programs. So readability of a program and management
    of a program becomes an issue if you if you if you do not assign the names of the variables
    carefully. However, if you write the names very in a very descriptive way, by just writing
    the name of the variable by just creating the variable symbol or or or the name, it
    tells a better look and feel of what kind of data inside and what should I do with that.
    So, I was talking about this equal sign this equal sign is used for assignment. Here for
    examples when 7.2 is assigned to a variable x y, automatically the type of x y variable
    is set to be a floating point integer floating point number a float is a data type in in
    Python that describes that the particular data is a real valued it may have a decimal
    expansion as well not just integer and floats are the only data types in Python, there are
    several others for example, you can define complex numbers if you if you want to you
    can for example, defining a complex number might be for example, you write the name of
    C and you write two plus four j if you write the symbol j here, it automatically becomes
    complex. And now you can you can use this see the way the complex numbers should be
    created. Similarly, there are other data types like fractions decimals, there are there are
    further data types, the objects called strings. For example, if you if you if you assign let's
    say s equals double quotes Hello
    then that S is also a variable and the type of this variable a string string is just a
    sequence of a lot of collectors, where he is a collector is a collector L is a collector
    L is a collector always a collector W is a vector. And when we will define anything,
    any sequence of characters inside the double quotes and then ended the double quotes here,
    or the single quotes, single quotes and double course either way, then the type of this is
    become strings. And these characters should be created as it is. Like for example, if
    we have another variable s two and we just say one, two, in double quotes. Now this s
    two is no longer 12 as an integer. It is a sequence of characters where first character
    is one and other graduates two, we will talk about strings in detail in the upcoming videos
    but just to give you a look and feel that Python actually supports a lot of data types,
    a lot of interesting data types including the most important data type is integer float
    and string as well that we will see in detail. Further you can assign you can assign more
    than one values to more than one variables in in a single line there is sometimes called
    multiple assignment. For example, if you write a comma b equals four comma 5.00, then four
    will be assigned to a and 5.0 will be assigned to B. notice one thing although 5.0 looks
    like an integer, but when you when you write a decimal expansion, it automatically becomes
    float. So, if you Now type the type, if you now check the type of a it will be integer
    and if you check the type of B it will be float. Once you have declared a lot of variables,
    they stay in the memory they occupy a particular space inside the memory. For example, x is
    just a label to a memory inside the memory that is to located somewhere. Similarly, y
    is also located somewhere in memory. And similarly x y is also located somewhere in memory. And
    this is the data inside that memory. These will stay in the memory and the occupy the
    memory. If you if you decide to no longer use a particular variable and future in the
    in the program, then you can call this function d l space, whatever the variable name, and
    it will delete the it will delete the variable from the memory like it was never there. And
    once the variable is no longer in memory, it is it is not accessible. If you now access
    the variable again, you will get an error. Let's see all these concepts. Let let's see
    most of these concepts in Jupyter Notebook and let's let's actually, let's let's actually
    define certain variables, use them, print them, do some multiple assignment and see
    a lot of stuff in in Jupyter Notebook. So let's go to Jupyter Notebook. So that was
    our notebook that we were doing, that we were actually working on the last time. So let's
    say I define a variable X, let's say x is two. Why not? Why not? I should describe this.
    as what we are doing here is let's say variables. So just to give a heading that we are now
    in variables, so variables, notice that now I'm in a code cell. Previously I was in a
    markdown cell, notice this change in this particular cell, this is markdown in this
    particular cell, this is code cell, C that goes, Okay, x is equal to let's say, three,
    let's into this. Now x is assigned a value three. If you want to know how many variables
    right now are there in the memory, we can write this command whose This is a percentage
    symbol, if you write percent a symbol and then just type a command, w h o s, it will
    tell you all the variables that are on right now that are there in the memory. And right
    now the memory has a variable with name x, its type is integer, and the data inside the
    variable is three, that's the memory view that you're now seeing. Okay, if you want
    to explicitly check the type of x, you can print type x. So for example, this function
    type will will actually find out the type of whatever variable you give inside and then
    this print function will help you printing that on on the notebook. So if you see the
    type of x, the type is basically its integer type. Now,
    if you for example, change the value of x as three to let's say, 5.7. So you have same
    variable, but you just change the value from three to 5.7. So let's see what happens now.
    So if we call us again, we have now the variable name is still x, but its type automatically
    it's type automatically change to floating point number, because of because we assign
    a floating point number to it. And this is the data if we want to explicitly check the
    type of this x, that would be class float now, further. Let's say we have another variable
    ABCD. That's a variable name, let's say and we assign a value 55 six Point, three, two,
    that's that's the value. If we now called whose function whose command, we will be having
    two particular values, one variable as ABCD, its type is float. another variable is x,
    its type is float, and that is there. If we, for example, do a multiple assignment, for
    example, a comma, when you write comma, first variable finishes, second variable starts
    A, B, C, D, F, let's say these are five variables. And if you assign five values to five variables,
    again in a comma separated list, 356, point 07, point two, and let's say minus three.
    So if you enter that, and you now check the status of the memory, because now all these
    values are assigned to the respective variables, if you now check the memory view, a is an
    integer type variable with value three ABCD, the old variable that we assigned earlier,
    it's already float B is also integer, it has value five sees float, sees float all those
    6.0 looks looks much like integer. But when you when you write a point explicitly, it
    becomes it becomes a floating point number. So D is again, float with 7.2, f is integer,
    it's minus five. And x is the old old variable that we know already. Now, if we, for example,
    delete a particular variable, if we for example, we we no longer want to use ABCD variable
    ABCD. That's one variable that we don't want to use in future. And now if we see again,
    the view of the memory, we don't have this and if we now want to access this, for example,
    if we want to print this ABCD, we will get an error, we will get an error and we should
    we should get an error because this particular variable does not exist in the memory, it
    points to no data, it has gone, it has gone like it was never, it was never there. So
    that's about the variables. We just talked about integer and float, there are several
    other variable types as well. For example, let me just give you an example of an example
    of a complex number, if you are really interested in that's a complex number if you print its
    type so that the type is complex. Similarly, you can have a string variable, let's say
    hello, how are you? That's a string variable, if you bring the type of this you will get
    a string we will we have a whole set of videos just on string data type, because this is
    very important data type we will we will see that in detail. But the purpose here is just
    to tell you that there are a lot of data types that Python supports and Python is dynamically
    typed whatever content you are assigning to a variable the that content decides the type
    of the screen you need not to specify.
    So I end this video here. In the next video, we will be talking about operators basically
    what kind of so once we have decided once we have declared once we have defined a lot
    of variables, what we can do with these variables, can we add two variables together and get
    the result stored in another variable can we multiply two variables together, can we
    have an operation like addition or mixed types for example, one variable is a floating by
    number and other variable is integer number integer type, can we mix up those can we add
    two different types of variables together and get a result then what will be the type
    of the result and so on. So a lot of these discussions on operators the very basic arithmetic
    operators on these variables, particularly the integer and float variables, we will see
    that in the next video, so hope to see you in the next video. So in the last video, we
    saw variables and we particularly saw integer type variable and floating point, variable
    type. We also saw very briefly on Jupyter notebooks are complex, and string as well.
    So in this video, we are going to talk about operators, basically the arithmetic operators.
    Obviously, if you are defining variables, you're not defining the them the variables
    just to just to view them later on. Most probably you will be storing data to the variables
    and then you are you're applying some computation on a set of variables together. Comparing
    new results saving that and doing some stuff, most probably you will be adding to variables
    some one way or the other in inside a program, you may have to add two variables, you may
    have to subtract a variable from the other, you may have to divide a variable you may
    have to compute for example, these are arithmetic operators, let me let me just this this plus
    symbol is used to add to variables. This minus symbol or subtraction is used to subtract
    a variable value from the other variable value. Obviously, these all are operated on values,
    not the names. Division, it like like the name suggests, it's if you want to divide
    this this person to a symbol when it is applied to two different variables, if x is on left
    and y is on right, what it does it, it actually divides x by y, and checks what the remainder
    is, for example, if x is 27, and y is five, then what's the remainder? What do you think?
    If we divide 27 by five, what's the remainder the remainder will be? Two Yes, so the result
    will be two here. So this computes the remainder. This multiplication this star symbol is used
    as multiplication like in mathematics, we normally write this cross symbol. But in in
    Python, and in most of programming languages, Star symbol is used to achieve multiplication.
    This double slash is like the division, but it is division with the result flow to the
    quotient. What I'm saying is the following. For example, if you divide, let's say 10.
    by three, the result will be a floating point number, and the result will be 3.33. Something
    like so. But if you want just the quotient, not the remainder, if you want the integer,
    that's the quotient value, then you write the double slash three, and it will return
    just the value that is that is there before the decimal expansion. So this value will
    be returned. So this is kind of the integer division or floor division, this double star
    is used to compute the power. For example, if you want to compute to the right doublestar,
    four, that means two raised to the power four in mathematics, we write this as following.
    And the result will be 16, you can save that result in another variable, or you can just
    print it or you can write that in a file of whatever. So these are most important. operators.
    One thing that I want to tell you that these operator are not just for integers and floating
    point numbers, the applications of these operators is much broader than these later, we will
    see the objects or the data types that are collections. And very, I mean, the data types
    that are beyond these integers and floats, and still there, this plus minus division,
    and all some of these are all of these, they have their meanings there. Even even even
    this plus is used for strengths. Now think for example, if you have a string, let's say
    hello.
    And you have another string, for example, let's say this is string s one, and you have
    another string, let's say s two, which is why then Python allows you even to add these
    kind of data types, although some doesn't make any sense with these kinds of string
    variables, but we will see four different kinds of data types. The the definition of
    these operators, they actually changed or adapted accordingly. For example, in mathematics,
    we are much more fluent a four with plus with Debian with subtraction, and it makes sense
    to add two integers to subtract a floating point number from another floating point number
    and stuff, but with data type that is unfamiliar to you right now, these operators may not
    make that sense to you. But there are definitions there, there are ways to use these variables.
    For the data types that are even there or even beyond an integer and floating point
    numbers, we will see all these details as we move on, as we move on to as we move on
    to the videos. And I mean, as in later on, we will see all these things in detail, but
    just to tell you that these operators are not just limited to integers and floating
    point numbers or complex numbers, they can be applied to several different data types.
    So a lot of words, I guess you were born Now, let's go to Jupyter Notebook and have fun
    with these kinds of concepts that we are dealing with. So yeah, here. So let's first press
    escape, then m just to change it to markdown and then good scape one for heading begetting.
    And here I write, let's say operators, and shift enter its runs and automatically then
    go to code. Okay, now let's say I have a variable. So let's say what kind of variables I already
    have. In the previous video, we use that. So we already have these kinds of variables
    with us. Now, what is let me define a new variable, let's say sum of sum of A, B, that's
    a new variable sum underscore AB, that's a variable name, you can have a better way you
    will name maybe some of A and B, that might be a variable name. It is good to have the
    variable names that are descriptive that describe what data is inside. Because in in programs,
    the programs become manageable, readable, and a lot of benefits are there. So Sum of
    a and b, let's say that's a variable name. And you add a, b, you just write a plus b.
    Let me make the zoom level a little high so that you can see it clearly. So a plus b,
    let's say that's there. If you press Shift, enter, and now your brand. Some of By the
    way, if you have written some of you need not write everything, just press tab, and
    it will automatically complete the remaining part of the variable and press Shift Enter
    and you have eight. If you check the type of this variable, some of tab automatically
    completes tab complete that is called tab completion, while it's integer, the type of
    this particular variable is integer, that's a new variable and why and the type is integer
    because a was integer, B was integer. And integer plus an integer is an integer. What
    if we add an integer with a floating point number? What do you think? What should be
    the result? If I just type type? A, that's an integer plus d with some floating point
    number. So a plus d, the result will be here, and type of that result. What will be the
    type of that result? What do you think? Let me pause here for a few minutes, and oh, no,
    no, no, not for a few minutes. For a few, maybe seconds, maybe two or three seconds,
    what will be the result? What will be the type of an integer and a float combined?
    Well, the types are up costed, which means the floating point number, the result will
    be a floating point number. And the reason is, every integer by default is a floating
    point number, a floating point number is a is an upper class, or you can say a superset.
    So in Python, in Python, by default, the types are up costed to super super sets. So here
    integer plus a float, the result will be a floating point number. And that's a result,
    you might be thinking why we have why we haven't stored the result in another variable. Well,
    if we want to store the result in another variable, we can, or if we just compute the
    result and apply some operation on that, we can do that. For example. We could do the
    following, for example, a plus d. That's whatever the result is raised to the power three, whatever
    the result is, whatever the result is, divided by maybe four. And we just save that in a
    new variable. Let's say. Let's say the new variable is V. Let's say we save that value,
    and V. And now we print we, and we have the result for me. Wow. So we can do a lot of
    stuff with these kinds of variables. Let me show you a fancy stuff that we will see later
    on. Don't worry if you don't get it just as one, for example, as one is Hello. Hello,
    and let's say s two is world. And we have another variable, let's say s, which is s
    one plus s two. What it will do is it will just concatenate them together. We will see
    strings a lot later on. But just to tell you this plus is not just for not just for numbers,
    it is for other data types, very fancy data types that are there. One more thing, let's
    say we define 10 and we divide it by Three, and we want a quotient, the quotient is three.
    However, if we have 10 divided by three, Shift Enter, the result actually is 3.33, and so
    on, you might be wondering we have not saved that result in a particular variable. So where
    the result is saved, actually, if you do not, if you do not save the result, if you do not
    assign the result, for example, in this way, the result will be assigned to a variable
    or, but if you do not assign if you do not store the result in a particular variable
    explicitly, by default, there is a variable in Python, which is underscore underscore
    contains the last result that you did not store in a particular variable explicitly.
    So, that underscore is basically one default variable for for the result, if you want,
    don't try to update this underscore, just just read it Do not assign anything to underscore.
    For example, if you assign something to underscore assignment will be done, but then the properties
    of underscore will no longer be there as they are in in Python built in properties. Okay,
    so, that's about it, I guess. So that was the operators, we will see the operators more
    and more later on. But before ending this video, I leave you with a question. So the
    question is, we saw the variable names like, Sum of a and b X, Y variable name can be can
    be lengthy can be descriptive can be short anyways. So the question really is, can a
    variable name start with a digit? For example? Is it possible that the variable name really
    is is starts from the variable name starts from for example, a digit? is a 3x? valid
    variable name? Or, for example, at the rate of at the rate of Why is that a variable name?
    Or, for example, this symbol times two times x, is that a variable name? What are the conventions
    to for variable names? can we can we write anything? In the left hand side? The right
    let's say 3x? Is equal to four? That means 3x is now a variable name. Is that true in
    Python? Or are there conventions to define the variable names? So?
    Yeah, think about it. See you in the next video with the answer to this. So I hope you
    will, you will be having answer for this question. Hope to see you in the next video. Okay, so
    in the last video, I asked you a question about the naming convention of the odd variable
    names. In particular, I asked you whether 3x is a proper variable name or not in Python?
    So what's your answer? Yeah. What do you think? How many of say, how many of you say no? How
    many of you say yes? Well, by the way, you might have tried that, declaring that variable
    name and Jupyter Notebook, and then you might have got this answer one of these? Well,
    let me tell you, the answer is no. A variable cannot start with a digit. Not with, not with,
    at the rate of not with hash symbol, not with I mean, there are several
    other special characters are not there except a few factors. One of those is underscore.
    Let's go to let's go to Jupyter Notebook and and check this. So, for example, 3x equals
    five error, invalid syntax, let's say activate of y equals four. Invalid star d equals four
    error. Well, an exception is underscore underscore E equals six, that's allowed. Starting a variable
    name with underscore is allowed, it is different than the underscore that is built in underscore
    this underscore E is different than simply underscore. So it is good to not declare the
    variable names that start from these because you will be getting errors further. variable
    names should be descriptive. They should give you a look and feel of the data what they
    are containing and you're free to define variable names, as as descriptive as you want. So it
    is a good practice to, to start writing the variable names in a better way. One, one better
    notation, one better notation of defining these variable names, even the function names,
    we will see the functions later on. One way to defining those is to use camel notation.
    camel notation camel notation is you start with the variable name with for example, lowercase
    letters, let's say your variable is starting time of the course. Let's say that's your
    variable name. So you write starting, that's one word finishes, then the next word should
    start from capital T, starting time of the course, let's say. So this kind of notation
    is called camel notation. And very famous, particularly the Java developers, they normally
    follow this and several other developers. But you should come up with a notation that
    is one notation, there are other ways of keeping consistently keeping the consistent strategy
    of defining variables. There are several other ways this is one way. So starting time of
    the course is let's say 2.0. That's it. So that's a variable name, if you if you now
    check, that's a variable name. But now, if you see this variable, just just the name
    suggests the data inside is doing what? So the names should be descriptive, I mean, and
    make that as a habit. So, yeah, I guess we have now answered our question very concretely,
    that variable name cannot start with a digit not with any special character other than
    underscore, okay. In the next video, I will be introducing comparisons with with variables.
    For example, what if you want to compare whether one variable is smaller than the other or
    not? What if you want to compare whether the two variables they are containing values they
    are same or not? What if you want to do comparisons of the of the data that is stored inside the
    variables, and based on the result of the comparison, you want to do something else.
    So in the next video, we will see a bool data type that is very, very famous, and it is
    used in a lot in decision making. And we will see the comparison operator sometimes called
    the relational operators in the next video, so hope to see you in the next video. Okay,
    in this video, we are going to talk about a data type which is called bool. That's very,
    very famous data type. Actually, it's the most famous data type because it is used in
    decision making all the control flow most of the controls, so depends on this data type.
    Although it is very, very famous, very much applicable data type, it is very simple. It
    is a data type with just two states with just two values. By the way, there are capacities
    of different data types. For example, in T integer, the
    different kinds of values that you can store are huge, you can store any negative number
    in it, you can store zero, you can store any positive number, the capacity of floating
    point number or the number of values that it can save is is even higher than even higher
    than integer and the complex number is even higher than that and so on. But the bool data
    type, it has just two states one state is true. It has just two values. True is a value.
    And false is a value just these two straights true or false. In some programming languages,
    the true is denoted by one, and the false is denoted by zero. But in Python, the true
    is just t ru e true that thing and false is false. That's it. If you For example, define
    a variable let's say any variable name, whatever the name is, let's say B and you assign true
    then it's its default data type will become bool. And if you have another variable, let's
    see which is false. Then C is also bool. One thing that is important, there are other operations
    other than arithmetic operators that we saw, adding subtraction division and stuff, there
    are other operators that we can apply on bool datatype. For example, a true and and is a
    keyword combining true and true. If if there is a variable, let's say a with a There is
    a boolean variable a with data true. If there is a boolean variable b with data true, then
    a and b is also true. So let's say I've used this variable D, in storing this A and B,
    the D will also be true. So true and true is always true. Further true and false, this
    is always false. And this is committed if for example, true and true is true, true and
    false is false, false and true is false, false and false is false. So, if you apply an operator
    and keyword to combine the two Boolean variables together, if both are true, then and will
    result a true otherwise and will result of false other than this and there are there
    is there is another, there is another operator, keyword or so, this results false. If both
    are false, false, false, false or false is false. If any one of these is true, then the
    result is true. Remember the difference between n and R and will result false if any one of
    the two operands at least one of the two operands is false,
    then the result is false. If both are or are anvisa true, if both of the operands are true,
    otherwise it is false
    or will result false if both of the options is false or false. Otherwise it is true. So,
    you now know and you now know are there is another operator called not. This is not so
    not for example, returns not true. Results false and not false. returns true. Great.
    So knot is a unary operator. unary means it just takes it just takes one variable and
    operate on that, and is a binary operator like plus is a binary operator. It takes two
    variables to operate on, or is a binary operator it operate, it takes two operators, it takes
    two variables to operate on and so on. So remember, remember these things, one, and
    we'll return true if both of the variables are true, otherwise the result is false, or
    will result false. If both are false. Otherwise, it will return true and not is not just flips
    the the state. So not true means false, not false means true. So these are basic, that's
    how you can combine the Boolean variables together. In the next video, we will be seeing
    how to apply these comparison operators and the result will be Boolean types. And how
    can we combine the Boolean types together to to build a better decision making. So in
    this particular video, I just, I just introduced the boolean data type for you with you. In
    the next video, we will see where the boolean data type actually appears, and how it impacts
    our, our our programming style or thinking style or coding style. So hope to see you
    in the next video with comparison operators that actually produces the Boolean variables.
    Hope to see you in the next video. Okay, in the last video, I discussed boolean data type
    and I discussed that a boolean variable takes either a true or a false and we can combine
    these Boolean variables together with and our operators. And then we can apply a knot
    operator on a particular variable. And we we saw that a true and true returns true and
    and otherwise it also returns false. Similarly false or false is false. Otherwise, or always
    returns of a true before before actually discussing these comparison operators. Let's do let's
    just go to Jupiter and just just play with a boolean data type. Just Just for just for
    a moment. Let us just convert this to markdown cell and just cried. Both that's a word Boolean
    variable. So let's say A is true and B is true and C is false. False. And okay, so these
    are variables. Let's press those to see what are the states of. So, a is a boolean variable
    with value true B is a boolean variable with value true C is a boolean variable with value
    false. So, now it is true B is true, C is false. So that means, let me print print a
    and b, what do you think? What is what will be the result? Let me print a and see what
    will be the result. And let me Brent? C and A. So because a and b both are true, the first
    result will be true, because C is false, false, true and true is true. The the other two statements
    they will result false. So first value will be true, then false false. So yes, true, false
    false. Let's, let's check the or print. And by the way, let's store that are in another
    variable, let's say A is true, or C is false. So what do you think what will be the result
    here, because or gives false when both are false, here is true. So the value of d will
    be true
    for the not a, because A is true, not a will be false. Similarly, not B, B is true. So
    not B will be false. Not C, C is true, C is false, and not c will be true. Similarly,
    not D, we can save the result in another variable, let's say D. and we can just check the type
    of D if we want, that's a Boolean, we can also check the value inside D and that is
    false. So, yes, not only that, I mean, we can we can we can we can combine at a higher
    level for example, A and A and B, whatever the result is, or C or D, whatever the result
    is, and whatever the result is not of that. I mean, we can we can combine them in a very
    complicated way. If we want a and b the result will be some Boolean, that Boolean and that
    Boolean there
    are the
    result eventually will be a Boolean, and then not have that. So let's check what if that
    is the result is false, well, why the result is false. figured out why the result is false,
    let me go to comparison operators. So, the comparison operators, let me just go through
    comparison operators. This equal equal to it compares whether two variables whether
    whatever the variables are whether they are integer floating point, whatever, whether
    two variables are are, they have same data or not, for example, x equals equals two y.
    That will be true if x and y, they both have same data. So for example, if X has value
    four, and y has value four, then we are just checking x equals equal to buy or not, the
    result will be Boolean. Because an X may not be a boolean variable y may not be a boolean
    variable. If we want to compare the values of x and y, then we write w equal without
    a space inside. Remember, if we write single equal that will be an assignment operator.
    If we write w equal that means we are checking whether the two values are same or not. Similarly,
    if we write this particular symbol that checks whether two values are not equal or not, for
    example, x is not equal to y, the result will be true if x and why they both have different
    values, otherwise the result will be false. Remember, the result of comparison is always
    a Boolean, it is either true or false. Okay, next we check whether less than So for example,
    if x is less than y, the result will be true. If x indeed has a value that is smaller than
    y, let's say x is two and y is 10. In that case, the result will be a true otherwise
    the result will be false. Similarly, we can compare the two variables using greater than
    we can compare the two variables by less or whether whether the whether one variable less
    or equal to the other. For example, if X is less or equal to y, the result will be true
    of this comparison the result will be true if X has a value that is not larger than why
    as long as x and y are equal or x is smaller than y In any case, the result will be true
    otherwise false. Similarly, greater than or equal to. Okay, so I end this video here in
    the next video, we will be, we will be moving to Jupiter and playing with these operators,
    and seeing the return types of Booleans. And then combining them together with ands and
    ORS and doing doing interesting stuff with that. In this particular video, I just talk
    about the comparison operators, the boolean data type and combining them by and or not.
    In the next video, we'll be first moving to Jupiter, we will see the comparison operators,
    we will write all these statements in Jupiter and just get a good hands on grip on that.
    And then we'll be moving on verse. So hope to see you in the next video. So in the last
    video, I talked about comparisons, w equal to not equal to less than, greater than, less
    than or equal to, greater than or equal to. So let's go to Jupyter Notebook and see how
    they actually work. So let me just first enter a markdown cell and type comparisons. Shift
    Enter comparisons. So we can we can compare different values by first assigning them to
    variables. And then comparing those variables or we can we can compare the values directly
    or for example, rent. Two is less than three. What do you think two is lesson three, the
    result will be what Remember, the result of a comparison operator is always Boolean, it
    is either true or false. So in this case two is smaller than three. So the result will
    because this statement is true. So the result will be true and true will be counted. Further,
    we can store that result in in another variable for example to is smaller than three, whatever
    the result is, the result will be true, the result will be saved in a variable, see, if
    we check the type of see
    reject the type of seeing as long as let's print the value of C. So you can see the type
    of C is Boolean, and C in this particular case is true. Moreover, for example, let's
    have three equals to four. Is that true or false? What do you think three equals to four,
    three, w equals to four, that is false, three is not equal to four. And let's save this
    result in D, remember three double equals to four, that's an operation the result is
    false. This equal is an assignment operator that the false value will be assigned to the
    variable D. and here we can see Brent D. Burn it is false. Similarly, what do you think?
    Three double equal to 3.0? What will be the result? Remember, three is integer. 3.0 is
    a floating point number. And I'm comparing three double equals to 3.01 is integer, and
    other is a floating point number. So what will be the result? Let's say the result is
    true, because they are comparing the values by discarding the decimal position. Further,
    let's see. Three is smaller or equal to so let's say x is equal to four, y is equal to
    nine. And z is equal to let's say 8.3. And r is equal to minus three, let's say and these
    are our variables. Let's see. So what do you think what will be the result here x is smaller
    than y. What will be the result of that x is smaller than y, the result will be true
    and z is smaller than z is smaller than y. The result is again true because the smaller
    than y or r r is r is equal to for example, x. So what do you think what will be the result
    at the end after this, so, let's see first first this will be true, this will be again
    true, and that is false. Okay. So, this true and true will return true and true or anything,
    the result final result is true. So, this will return or it's returning true. But, if
    I just do if I just switch the order, for example, if I just write this statement, which
    is false, this particular statement here and then I do this, what will be the result now,
    Now see, x is smaller than y it is true, r is equal to x that is false. So, this result
    will be false eventually, and z is smaller than y, that result is z is smaller than y,
    let me just say z is larger than one, let me just check z is larger than y, z is larger
    than I just just do just to tell you. So, this is true, this is false. Both of these
    are let me let me switch the let me switch the listing r equals to x, I just want to
    show you the precedents of r and x is smaller than y. So now, if you see this is false,
    this is true, false and true is true, true or false and true is false, this is also false.
    And the result overall is false. It should happen, but what if, what if this goes first,
    if this goes first, I mean, I want to show you whether and an AR, which one of them will
    operate first. So, in this particular case, the result is false, but it can happen let
    me let me tell you this in more and two, or false and true or false. And
    true,
    what do you think what will be the result here, true or false and true, if true or false
    operate operate First, if true or false operate First, the result will be true, true and true,
    the result is true. If however, let me let me just write a false here. If all operates
    First, if all operates first, then false or false is false and false and true is the result
    eventually is false. And if and operates first, then false and true is false, false or false
    the result in both cases here is is false. So, a better way of representing these kind
    of sometimes sometimes they can make confusions, sometimes they can make confusions, for example,
    if we have a true here, if you have a false here for example, false and true
    How can I so, false, false and false or true. So, in this case, if in this case, if false
    or true that operate First, the result will be true and false and false, false and true
    the result will eventually be false. However, if n operates First, the result will be false
    here, false or true the result will be true. So, here if and applies if you apply if n
    is applied first, then the result overall result will be true. But if all is applied
    first, then the overall result will be false. So it is it is good to know whether and will
    be applied first or off will be applied first in this particular case and will be applied
    first even if you even if you change this even if you change this order for example,
    if you even if you pick this thing and apply here still the result is and will be applied
    first and or will be applied after, it is always good rather than to one way is to remember
    the precedents and will be applied first then or, I mean it is good to think about the precedents.
    Another good thing is to specify the order using parentheses. For example, now, we specify
    this first our will be applied and then four and will be applied. So, it is good for readability
    to always apply these parentheses and and check the order in which ands and ORS and
    the combination will be applied. So, the in any way the result of these comparisons will
    be bullions. Question, what will be the result here? So, not to not equal to three and true
    or false and true. See this slide for a while. Even if you want to pause the video, pause
    the video, see it? and answer the Brent will return true or false. okay with this question,
    I end this video. In this particular video, we just saw the comparisons on Jupyter Notebook.
    Just see how the comparisons return true or true or false. We combine the different tools
    and different Boolean values using ands and ORS. And here is a question for you. Okay,
    I will see you in the next video with answer of this question. So I left you with a question
    in the last video. So that was the question if you remember. So the question really was,
    what's the what's the result here? So what's your answer? True or false? The result, either
    will be true or false, because these are all comparisons and combination of Boolean values.
    So let's see step by step. First of all, let's see this two is not equal to three The result
    is two is not equal to three Yes, it is true, two is not equal to three That's true. So
    not true not true is false. So, this is false. So, this whole thing is false. Now false and
    true false and true that is false. So, this whole thing here till here is false. Now we
    have or or and then we have false and true false and true is false. So, this whole thing
    is false this whole thing is false and or between false or false it is false. So the
    result of this. So the So the answer to this question is is false. Let me let me just convince
    you by typing the statement in in Jupyter Notebook. So, if you remember we have Brent.
    Brent, not two is not equal to three and then we were having I guess and false and yeah,
    that was a different one. And true, sorry, that was and true. So this was and true, then
    we were having our
    and then we were having these false and true. So the front ends here and the result is Oh,
    I have some I have some parenthesis mismatch. So not true and this okay, I should have this
    one I guess this goes to there and this goes to there and I guess Yes. So the result is
    false. The result is false. The purpose of this question was not just to the purpose
    of this question is to appreciate actually the fact how we can combine different Boolean
    values to to to achieve the final boolean value and these kind of combinations will
    become very, very helpful further in in control flow and we will see the if conditions and
    decision making and stuff so The answer to this question is false. Yeah, and I end this
    video here. In the next video, we are going to see some useful functions of Python. And
    after seeing the some some kind of useful, there are a lot of functions, we will see
    just a few of them very useful of them. And after seeing those functions, then we will
    directly jump to control flow basically the if conditions and stuff where you will see
    these comparisons, these Boolean values in a much more applicable sense, then then earlier.
    So hope to see you in the next video. Okay, so let's have a very quick tour over some
    some useful functions in Python. Obviously, there are a lot of functions in Python, but
    I will be covering just a few of them. That I think with the passage of time, we will
    be covering more and more but let's start a function are sometimes, particularly a built
    in function is is basically a feature from the language that is supplied for the users
    to achieve particular task. For example, around function. If you give round for example, around,
    let's say 4.6. This 4.6 is a floating point number, and rounding means make it as integer.
    And what round does is it finds the nearest integer to 4.6. And the nearest integer in
    this case is five, because five is more closer to 4.6, then four. However, if you call round,
    for example, on four point, let's say three, then the result will be four, because four
    is more closer to 4.3, than five. So that's one use of round eight rounds, basically rounds
    a floating point number to the nearest integer. Another use of round is if you give another
    argument that that is called an argument to the function. For example, when you write
    Brent. Brent, let's say a, this a is called argument to a function Brent. Similarly, round
    is a function 4.6 is an argument round is function 4.3 is an argument, we will see functions
    in details, and we will be writing our own functions as well. But for now, just just
    bear that just bear with me that functions are these kinds of features that are available.
    However, we we will be writing our own functions later on. So this particular function accepts
    two arguments surround has two different kind of implementation. One is when it accepts
    only one input argument, it returns the nearest integer to that, if it accepts a floating
    point number as well as another argument like here we have three, that means after after
    point, after decimal, go to three places only, and then round up, then round, for example,
    this 4.55 and then eight will be rounded based on its next value. If the next value is larger
    than five, then eight will go to nine and stop. If the next value is smaller than five,
    then it will stay as eight and the result will be three decimal places after this. So
    let's practice this round function just on a Jupyter Notebook very quickly. Let's see.
    So here we are. So let's see rent around, let's say 4.556. And in this case, the result
    will be 4.5. And the reason is 4.5. And it's rounded up, it stays to five and the reason
    is this 4.556, it is more closer to five then
    than four. However, if you if you just print round, four point, let's say 345. Let's see,
    and the result will be for the reason is 4.345 is more closer to four. However, if you call
    this round function with more than one argument, for example 4.556789 let's say or with argument,
    let's do that means the result should be only two decimal places after the after the decimal
    point. So in this case, the result is 4.56. And the reason is, this five is rounded based
    on the next digit and the next digit is larger than five. Hence it is rounded up. So 4.56
    If however, I call this function for three Then what do you think what will be the result
    it will be 4.55. And the six will be rounded up based on the seven, and it will become
    4.557. Yes. However, if, for example, there will be a value at at the place of seven,
    if there is a value, let's say three, then you call this function, then 4.556. And then
    based on the next value three, the six will stay as six rather than going to nine, and
    the result will be 4.556. Yeah, so that's, that's the, that's the round function. Basically,
    another function is diff mode, diff mode function basically divides and returns quotient, and,
    and remainder. So in the next video, we will be seeing this diff mode in detail how it
    actually works and how, how it is useful. So in this particular video we saw around
    function in the next video, we will see diff mode, and there are a couple of more functions
    that we will see in the upcoming videos. So hope to see you in the next video. So in the
    last video, we saw round function that sometimes accepts one argument and sometimes accept
    two arguments and behave accordingly. In this particular video, we are going to see another
    function dev mode. And it accepts two arguments, two different arguments, but maybe same or
    different arguments. And it it returns two outputs, two numbers, two terms basically
    quotient and remainder. For example, in this particular case, the quotient is five, and
    the remainder is two, because if five is divided by if 27 is divided by five, the result is
    five, but then the remainder is two. And the result is returned in a kind of an ordered
    pair. And these kind of collection in which we have two or more elements, we call these
    collection as tupple that we will see in detail when we will see the data structures module
    of this course. But right now just bear with me that it returns two numbers, two elements,
    and the two elements are ordered in an ordered pair, which is called a tupple. A tupple is
    not just an ordered pair, it can have three more three, four, or five or seven, or maybe
    several elements. But right now we will a tupple is just an ordered list, which we will
    see in detail. So let's see the working of the stiff mode function in in Jupyter. notebook.
    Let's see. So let's say we have dev mode. Let's say for example, we have 34. And then
    we have lots of them. Or maybe let's say nine, so what do you think what will be the quotient
    and what will be the remainder. So 918 27 So three, three is the quotient. And the remainder
    is remainder is seven. So three is quotient and salmon is the remainder. So and if you
    save the result, for example, if you save the result in a variable, let's say G. So
    if you see the G the type of G if you if you just type the type of if you just find the
    type of ci it's a tupple, which we'll see in details, and if you see the contents of
    G if you see the contents of G the contents of gr three and salmon, and if you want to
    access each element independently, then you can access the element first element, because
    the if there are multiple elements in in a variable normally that that kind of variables
    are called collections that we will see in detail later on. And these are the indexing
    the positioning is start by zero rather than one. So g zero means the first element of
    G which is three in this case, and the second element of G is one
    at one, which is seven. So, this is basically this is called the index or position of of
    elements or data in this particular collection, we will see these indexing and all these kinds
    of collections in detail in in the in the data structure scores, and we will see arrays
    and strains and different kinds of structures. But and default sometimes is, is basically
    sometimes it is helpful. By the way you can achieve dev mode by by another by another
    thing. For example, if you want to achieve a more 34 nine, you can do the same thing
    by let's say 34 divided by double divided by nine that will give you a quotient. And
    the question is three and further if you write 34, remainder nine and that will give you
    the remainder that you need. So you can call that function Dave mode. Or you can use these
    two there are multiple ways of doing the same stuff. Okay? So, yes, so, I mean, sometimes
    it's useful when you're going and knowing this kind of function that returns quotient
    and remainder. Okay, next function that is more useful is is in stance, and we will see
    this function in the in the next video. So hope to see you in the next video okay, this
    function is in stance, it actually returns either true or false. And it just checks that
    particular given data value belongs to this type or not. For example, if you want to check
    whether one has type integer, so, you can check that using this function by the way,
    you know that one is of type integer then you may think that why on earth one should
    be interested in checking the type of one if somebody no it is in teacher, sometimes,
    we have certain variables and certain data is stored in it, and we want to check the
    data inside it belongs to which kind of type and in several cases the value to this variable
    is not assigned by us It may be read from some file or maybe through input a user give
    some number or something like so. So, sometimes it becomes important to check the type of
    a particular way if we are if we are expecting a particular type of the input and the input
    is different than this function might be helpful. somewhere. Either way, this is a function
    available in Python and it checks whether the given value has a particular type of not.
    So is instance one int returns true is instance 1.0 integer that returns false maybe, because
    this is a floating point number, and you can check a particular value belongs to one of
    the several types or not, you can give several types in a in a tupple. And you can check
    whether it belongs to this, this or not. So, let's go to Jupyter Notebook and see, actually
    how it works. So, by the way, this is the same notebook that we have, that we are populating.
    So, hold on with me, at the end of the day, we'll be having one notebook complete. So,
    is in stance is instance, let's say three is that instance of integer The result is
    true in this particular case, if for example, we check whether is in stance 3.4 is that
    nmt? Is that an end user? The answer is no it does not end in Deezer. If for example,
    we check if this is not in nature, then maybe it is a float? The answer is yes. Or maybe
    we check that. For example, if that value is either float or integer, if it is one of
    these, then I mean check that particular value in this particular case 3.4 whether it belongs
    to one of these types, we can increase these types, for example. So, let's say we we gave
    a complex number here and check is in stance let's say two plus three j that's a complex
    number. And let's say we asked whether it is an integer or float or not, the result
    is obviously false. And the reason is, it is neither integer nor float or even if we
    give string there str, so, it will still say no it is not
    not any of these, but maybe there is a complex data type if you see that, that says yes,
    because it is complex. So sometimes this is instance becomes really useful. Next function
    is power. So power you can you can compute power by the way using using for example,
    if you want to compute x raise to the power y, you can use double star and that computes
    exactly x raised to the power y or equivalently you can call the function POW x comma y and
    that will give you the same result as this one. But power sometimes take three arguments
    as well. And in that case, it it a it performs the power function in a different behavior.
    So for example, if you supply three arguments what it does it it raise y to equate x raise
    to the power BI whatever the result is, then it takes the remainder by z and gives the
    result. So let's see the functioning of this power function in Jupyter Notebook. So let's
    say Baba, I want to compute to raise to the power for the result is 16. No problem. To
    raise to the power four, I can compute the result 16 this way as well. But here is another
    way, how can we use this to raise to the power for whatever the result is, then I want to
    take the remainder, by let's say, I want to take the remainder by seven, or two, so we've
    got four is 16, then if we take the remainder by seven, the result will be two. And that's
    the result two. So that's how you can use this power function. I'm just introducing
    you some built in functions that are available, there are so many functions that are available,
    I'm just getting you comfortable with these kinds of functions so that in future if you
    see another function that he had not seen here, you'll be able to use it and apply it.
    So in this particular video, we saw this is in stance function and this power function.
    In the next video, we will see one more function that will allow you to take input from the
    user. So far, we are supplying values or assigning values to variables directly, what if on the
    fly, we want to give the values and those values should be assigned to the variables.
    So in the next video, we will see the function, we will see a function that will allow you
    to give input from the keyboard, hope to see you in the next video. So in this video, we
    are going to see a very important function called input. This function is I mean, this
    is beneficial for taking input from the keyboard from the user. And the way to call this function
    is you type input. And then you type a message that actually describes the expected entry
    that for example, into something if you want somebody to or tell somebody to just incur
    let's say, a number, you can write into a number, or any specification to help the user
    to enter whatever input the user want to interest properly. One thing is that no matter what
    the user will enter, the variable a will be having type string, str. So even if you enter
    a number, let's say 12, or 34, or whatever, that will be received as a string. And then
    there are ways to convert string to number if that really was a number. So whatever you
    receive using input function will be a string. And then there are ways to deal with that
    string, if that was a number, how to convert that string to a number, and, and so on. So
    for example, let's see, let's see on the Jupyter Notebook, how it works. So let's see, for
    example, x is equal to input, enter a number. Let's see. And then then if I press Shift
    Enter, a prompt will appear in front of you, that will require you to enter a number for
    example, if I enter, let's say 56, and then I press enter, not Shift Enter, Enter, then
    x will receive 56. Now, you might be thinking this 56 is an integer, so the type of x should
    be an integer. But this is not the case the type of x will be a string. And the reason
    is, whatever you enter is received as characters five and six, even if you have entered something
    else that would have been received as a sequence of characters. So this is no longer a five
    as a digit five, six as a digit six. These are some characters sequence of characters.
    Now, if you want to,
    I mean, there are ways to convert this x, for example, maybe you want, let's say, y
    or x as int x. So this means you have now converted this string to integer and then
    whatever the result is, you have stored that result in x again, if you now see the type
    of x type of x, the result is integer. And you can for example, print x minus 34. And
    the result is 22. Because X was X was 56. So this input function is I mean, it is an
    one way by the way, if you if you're expecting an integer or a float value, for example,
    let's say you're expecting a float value, then it is good to write input, let's say
    enter a real number, maybe or any message, any message and then at this particular time
    at the time of import, then it is okay to convert that thing to float and it will become
    a float. Yeah, that's it. So, now, for example, you enter 12.5 if you see the type of a now,
    type of a will be float okay. But there are problems for example, if you are if you are
    expecting float and somebody enters into something that is not float for example, a or let's
    say B equals load, input enter are real number, let's say and then you press Shift Enter and
    somebody just interest let's say ABC. So, now, this is not a float ABC cannot be converted
    to a real number no matter what. So, you will catch an error there are ways to avoid these
    kinds of errors and programming program breaks using exception handling and there are other
    ways, but be careful I mean the user is not I mean the one who is going to enter the the
    enter the input if that that user is not restricted enough, then you can get errors. So, I mean,
    this is not the case that whatever you will enter it will be converted to a float if it
    really, if whatever you have entered is really to convert it is really convertible to a float
    then it can be convertible to a float, not otherwise. And at the input time, there is
    no restriction you cannot restrict the keyboard to enter water or whatnot, although there
    are ways although there are ways to do that. So that's about the input function. So, we
    have seen some of the functions, let me just let me just go through quickly we have seen
    input we have seen is in stands, we have seen diff mode, we haven't we have seen power function,
    we have seen the round function and there are several others. Yes, so from now on, we
    will be actually moving towards basically decision making based sometimes we will use
    these kind of functions, mostly you will be using input function, but sometimes we'll
    be using maybe other functions like these functions. And sometimes we will be doing
    decision making based on the ease and and stuff like so, one thing that I want to tell
    you is if for example, you know the function name, some function, let's say like power,
    you know, that POW power is a function, but you do not know how to use that function.
    One way is to just type question mark in front of it, and then just press Shift Enter,
    and in front of you, the documentation of the power will open up so it will tell that
    this is power, that's how it should be called and then some description will be in front
    of you that equivalent to x raised to the power y with no arguments, the two arguments
    are equivalent to x raised to the power y remainder with z with three arguments and
    so on, if you want to see implementation of this function as well. We will see the functions
    later on but if you want to see more about the help, you can type the double Sam equal
    a double question mark and more things should be open up in front of you. So, in this particular
    case, the small function does not have an implementation in Python. So, the single question
    mark and double question mark are the same at one more way is to use the help function
    help out and you will get a lot of information about the power how for example, help on built
    and function power in module built in. So this is power this is equivalent to this some
    key types and stuff like so, or for example, you want to know how can I use the input function
    for example, so you can write help on input and this is how this can be used. So sometimes
    it is okay if you know the if you know the name of some function, and you know how to
    use it, you can just open up the documentation right here in Jupyter Notebook by either using
    a help function or you can use just a question mark in front of the name and so on. So, that's
    about the functions. In the next video, we will be seeing the power of comparisons and
    the decision making or sometimes called the control flow. So the real fun will begin from
    the next video because we will be actually deciding which part of the code should run
    and which part should Not run based on based on certain conditions. So hope to see you
    in the next video. Okay, we are in control flow, the most interesting part of any programming
    language will assume that you have two numbers, you have taken two numbers from the user a,
    you've taken that number from the user using input, I have not supplied the input message
    here, the message is optional. It's a description if you supply that that's okay, if you don't
    supply even that, that's okay. So A is some number the user will supply when the code
    will run B is some number the user will supply when the code will run. Now, once you have
    a and b in front of you, obviously the user will supply that on the fly, you don't know
    what the value of a and b are. Because when the program will run, only at that time, the
    A will be populated and B will be populated. Your task is whatever the value of a is that
    is that you don't know whatever the value of b is that you don't know, the user will
    supply that value those values, your task is to print the value that is bigger than
    both. So for example, if a is bigger than B, then print a if b is bigger than a, then
    print B. So whatever the bigger value is, print that value. Let's say that's your task.
    How can you do that? So the question is how does Python allows us does Python allow us
    to do that, for example, if a is bigger than we should print a, if b is bigger than we
    should print B, remember again, and again we are we are talking in terms of if A is
    bigger, if so this is this is this is what if a is larger than B, then this condition
    will be true. This is like the comparison. So this is true, but then we must have an
    F condition as well. If A is bigger than to what, so if a is bigger than B, then do certain
    things. Otherwise, don't do that. Those kinds of things. So this if condition is really,
    really powerful, and is available in all programming languages. In here, for example, let's see
    if a is an input B is an input, writing an if condition, that's if is a keyword. That's
    a comparison that we have done earlier as well. And then the syntax required a colon
    in front of that. So if this condition is true, if this result, if this comparison results
    to remember the comparisons, they return Boolean values, if this comparison, if this, whatever
    the result of this operation is if that is true, then you go into this block. And whatever
    the statement inside is do that, for example, print b is greater than a.
    Now my question is, is that is that done? Are we done with the task, the task was to
    print the bigger number. If b is greater than a, then B will be printed then or they might
    have printed, for example, we might have printed rather than writing this we might have might
    have printed, let's say just print B because b is bigger. If b is not bigger than a, what
    will? What we will do them. So yeah. If b is bigger than a then B will be printed? Yes.
    Because then you will be inside here. If b is not bigger than if this condition is false.
    We will do what then? So that's a question. So right now I'm just coding this in Jupyter.
    notebook. And then we will see how can we deal with that if b is not bigger than a kind
    of condition? So let's first see the blessings of if condition and Jupyter Notebook. Yeah,
    so let's say a is an integer. Let's say you're expecting an integer input. input, let's say
    and then you write if, let's say B is again, an integer input maybe. And let's say if a
    is greater than b, then print a. That's it. That's your program. Remember, this indentation,
    I have not written this print here. This is the indentation that defines the block of
    a let's say if I want to print a, then I want to print, let's say, I am still inside. If
    condition, condition, and so whatever that starts from this, whatever that starts Form
    whatever that starts from this alignment, if I write something here, let's say x is
    equal to five, all that block all that block is called the body of the if condition, if
    it starts from this alignment, If however, I I typed a statement, but I typed that statement
    in that kind of alignment, the alignment like this, this is no longer inside the if condition.
    So, for example, here I type I am outside the if condition. So, the purpose of writing
    these multiple lines is just the if condition does not require to contain only one line
    of code, it can contain a whole block of code multiple lines of codes. So, this is no longer
    inside the if condition. So, now we will take input a input B, whatever the numbers will
    be, if the value in a will be larger than B, then this will be printed and this will
    be printed. Once these two are printed, then this has to be printed regardless of the values
    of a and b, because this does not this last sprint statement, it does not depend upon.
    This does not depend upon the values of a and b, it has the if condition has no impact
    on that, that is just a sequence of statements. the if condition, the statement inside the
    if are just these two. For example, if a is not bigger than B, then neither this will
    execute, nor this will execute. But this will still execute because this is this has nothing
    to do with the condition. So let's run this code and see how it works. So let's set the
    value of a see the power of descriptions. If we could have written a description, then
    the description could have been could have appeared here. But let's say this is the value
    of a let's say 12. The value of b let's say, let's say 10. In this particular case, because
    the value of b is 10, the value of a is 1212 is bigger than B if this condition is true,
    this statement becomes true. Whenever this condition becomes true, you're inside the
    prints you are inside the if condition. Now this print executes and you're you get well
    this print executes and you get I am still inside the if condition, and this has to execute
    no matter what the values of NBR so now let me read on this and give other values of a
    and b let's say the value of a is 10. And the value of b is let's say 45. Now, this
    can this condition becomes false because 10 is greater than 45 this is not true, this
    is false. So whenever this condition is false, you never land inside the if condition
    and you go out from the if condition. So these are the statements that are inside the if
    condition
    they cannot execute because because you never visit them, they can only be executed if condition
    becomes true. So then once you're out the if condition that's the statement there is
    going to be executed anyways. So yeah, so that's the flavor of if condition on the see
    and making and this is the comparison operator that returns a Boolean value. You may have
    different kinds of comparisons here or combination of comparisons here No, no problem depending
    upon your logic. But the question is, are we done we are going to print only the bigger
    number we have, we have printed the one that is if a is bigger, we have printed that what
    if if b is bigger, we have not solved the task yet. This is the task we have not solved
    the task yet. So how to do it. Okay. So yeah, it looks like complicated. How to print only
    that number that is bigger. So if b is bigger than a, then we will print B. Maybe Maybe
    we should make maybe we should apply another if condition. If b is bigger than a then print
    B. If A is bigger than B, then print eight, maybe. Yeah, why not? So
    um,
    so for example, let's go to Jupyter Notebook and, and write the following. Let me let me
    write a whole new program here. A equals and import. Okay, let's do not have a message
    and input and then if A is bigger than B, then print a. Okay. However, if B is bigger
    than a then print B, I guess we are done. If this condition becomes true, then we are
    here and we know if this condition becomes true, then this condition cannot become true,
    because it cannot happen there is because then B as well as B is bigger than a This
    cannot happen. So, whatever the bigger number will be that will be executed further you
    can see I have this if condition and this if condition they are aligned in a way that
    this if condition is not this the second if condition is not inside the body of the first
    if condition, we will see such cases such cases when this is required. But right now,
    I guess we are done. If A is bigger than B, then print a, if b is bigger than a then print
    B and only one of these if conditions will become true, because A is bigger than B B
    is bigger than a, these two statements cannot be true at the same time. So, let's see. So
    A is 10, b is 45. So the answer is 45. Well, because 45 is bigger. So let's run it again.
    So A is let's say 22. b is let's say four and the result is 22. Because 32 is bigger,
    I guess we are done with the task, we have used this if condition twice to achieve the
    task to print the number that is bigger and both the numbers we we took both the numbers
    from the keyboard Yeah, I end this video here. And in the next video, I will tell you more
    features of this if condition particularly the L statement, whatever what we have done
    recently with another if could could be achieved through an L statement that is more powerful
    and more readable. So in the next video, I will talk about ELS statement which is a part
    of F so hope to see you in the next video. Okay, in the last video, we saw if condition
    and we actually had an example in which we wanted to know we wanted to just print the
    greater number. So we input a number a we input a number B and if b is greater than
    a we printed the is greater than eight, then we applied another if condition to check if
    a is greater than b, then paint a the else clause or the else part of f is as as the
    name suggests, if this condition is true. So, if this condition is true, this particular
    condition is true, then go there. If this is not true, which means else if this is true,
    then go there, else go there. So if this is true, then you learned here, if this is false,
    then you learn else part for sure. And this else is I mean, if b is greater than a if
    this condition is true, then you print this thing. Otherwise, a might be greater than
    B or A might be equal to b either way you learn in else part. So this if and else they
    both have this alignment, but then the block of ELLs started from this particular alignment,
    maybe you have more statements here, the alignment of this if block structure from here, and
    you may have more statements here. So let's go to the Jupyter Notebook and see the else
    running. So let's say a equals and input and B is
    B is int input and we say okay, if a is greater than b, then brand a
    else else rent else brand be elsewhere outspent B. Now B will be printed, even if it is equal
    to A or if it is greater than a either way, B will be printed. So let's just see. Let's
    just run this and see what happens. So Shift Enter. So input a number. So A is let's say
    10, and B is let's say, 12. So what do you think when I will press enter what will be
    printed, B or A, B, B is printed, that's what B is printed. Now, if I run this again, and
    a is done, and B is done, still the 10 will be printed. So let's modify it, let's, let's
    just say, print. If part. So that means we landed in if part. Otherwise, we landed in
    Ellsberg. So just to be more elaborated, let's say so 10 and 10. And we landed in L sport.
    And the reason is if a is greater than b, so 10 is greater than b 10 is greater than
    10. False. So you got two L's, and the LS block, the whole block just executed. So that's
    what else is, it's really very nice to have an L state or whatever this whenever the,
    if this is false, whatever that condition is, if that is false, then you learn in else.
    So yeah, that's the health part simply now, okay. So, we have this f l structure, we can
    have one more power with this F, what if we want, if a if b is greater than a, then you
    print B. Else, if A is equal to b, then you print they're equal. And if this is false,
    and this condition is false, if both these conditions are false, then you go to else
    part. So basically, if else if else if else, if else, so, you can have really deep structure
    for example, in this particular example, if b is larger than a, then you land in this
    part else, if this L is just short form of else, else means B is not greater than a else,
    you can have another check elsif A is equal to b, then do what?
    l
    l, if we can have one more check, we can have one more check, we can have several checks,
    and then else else will only execute if all if conditions or elsif parts on top. Their
    conditions, they are false, and only then else will be execute. So let's see these l
    diff running on Jupyter. notebook. Okay, so let's say a is and so rather than taking inputs,
    let's say is one, B is let's say five. Let's say we have taken these inputs is one B is
    five, if A is if a is equal to b, then the word rent equal l l F, which means else if
    now, because this is if you should you have to write a condition here, which will be either
    true or false. If A is larger than B, then do what? then print, let's say, a. And else,
    let's say your brain be okay. So that's it. And this statement, rent is not in if condition
    Not, not in if this is outside complete, this is complete if condition with all its L's
    and LDAP parts, and this is no longer inside. So let's run this. What do you think what
    will be the result if A is one B is five, then else bar is going to be run because A
    is not equal to B, A is equal to b that's false is larger than B that is also false.
    So you will learn in export and B will be printed and then a statement will be printed
    which is not an F. So yeah, so B is printed and not an F. If b is 10, then what will happen?
    A equals to B that is false, so you will not land here. Else if A is larger than B true.
    You will land here because you land here else will not execute. So He will be printed and
    then not enough. If A is 10 and b is also banned, let's say, then you have equal. Yeah,
    so that's elsif. Okay, so that's about if else if else if or short form is lf l structure.
    In the next video, we will be talking more about this if else if else structure in a
    bit more detail. And we will also be giving you a short form of this this guide of ELLs
    if elsif elberfeld of structure. So hope to see you in the next video. Okay, one way of
    writing this, if elsif else kind of structure there is a short form as well, which is written
    down here in a in this green color, for example. This is kind of a same code that we saw in
    the last video, but that's the short form, let's say a equals nine and B equals 10, then
    print a if A is larger than B, else print this particular thing, if A is equal to b,
    l sprint that this is exactly the same kind of structure, for example, print a, if A is
    larger than B, so you just read that if a is larger than B, then print a else if A is
    equal to b, then print equal, else print that. So that is kind of a short form of writing
    this if Elif else kind of structure. But I will, I will recommend to to to use, I'm in
    the structure in this particular horizontal form. Rather than writing that in this particular
    way. Because this kind of structure, that horizontal kind of structure is much more
    readable, much more manageable. And this might be this structure might be confusing some
    time for for some kind of readers or, and also if this structure goes on and on and
    on, which we'll see in a in an example today. Writing that writing very deep and lengthy
    structures in short form is not very feasible. So although but but this feature is there
    if you like to write if elsif else kind of structure in this way, this is available in
    Python. Okay, let's let's get a good grip on this f LS f l structure on Jupyter. notebook.
    Let's move on to Jupyter Notebook. To see an example, just an example. So let's say
    the example is user will input a number, let's say int input, let's say and enter marks,
    let's say enter marks for a particular subject, let's say user with enter some some marks.
    And our goal is if the marks are larger than 85, then we will print a grade. If the marks
    are larger than larger than 80, but smaller than smaller, so if the marks are larger equal
    to 85, then we will print a grade. Else if marks are larger equal to 80, but smaller
    than 85, then we will print a minus grade. And if else if if marks are larger than larger
    equal to 75, but smaller than 80, we will paint we will print for example, b grade for
    example, b grade, and so on, let's print this whole nested structure that let's let's make
    this else. if else if elsif kind of structure a little empty, let's let's get comfortable
    with it. So if a is larger than or equal to 85 to enhance readability, it is good to include
    a space is a space after the variable and space but don't actually write the space inside
    there because larger and equal to the combined without space is an operator. So if a is larger
    than 85, then print let's say a grade rate l if A is a is larger or equal to a D and
    E is smaller than 85. So let me let me write this in a more readable form. Else if A is
    smaller than 85 and is larger or equal to 80 then we should do what it is sometimes
    good to include these kind of parentheses sometimes it is good just to make these things
    more readable that this is one block. This is one this is one Boolean, this is one Boolean,
    this is one to see and this font is E and although not writing the parenthesis is also
    okay. But writing the parenthesis make code a little more readable. So, for example, if
    a is smaller than 85 and a is larger than 80, if that is true, So, remember and is true
    only when the left side is true and right side both are true, then this whole condition
    becomes true. And I promised you that I will show you the power of comparisons and actually
    combining the Boolean variables using ands and ORS and stuff like so. So here you're
    seeing the one. In that case, let's say brand. Let's say a binary sprayed and Elif if he
    is if he is smaller than if he is smaller than 80. And a is bigger or equal to 75. If
    that's the case, then what should we do? Let me omit the parentheses just to show that
    whether writing parenthesis or not writing parentheses is perfectly okay. I just recommend
    right parenthesis, so the code becomes much more readable than otherwise. Okay, then we
    have Brent, let's say, b grade. And let's say one more lF lF. If A is smaller than 75.
    And a is larger or equal to let's say
    70. samedi, then Brent b minus grade, let's say. And let's just finish this let's else
    print. below. Average, for example, let's say that's it, that's our, that's our record.
    So, we will we will enter numbers, if the number is greater than 85, then a grade if,
    when this condition becomes true, then this print will execute. And we will out of the
    structure right there. If this condition is false, then this condition will be checked.
    If this condition becomes true, then this print will execute. And we will be out of
    this structure. If this is false, and this is false, then this will be checked. If this
    is true, then we print degrade and we are out. But if this is false, then this will
    be checked. And if this is true, then we'll print b minus grade. And we will be out. If
    this is also false, then we will dive into L sport and we will say okay, below average.
    So let's see, for example, let's say the marks are at two. So a minus grade. That, that that
    that makes sense, a minus grade because the marks are smaller than 85 and larger than
    larger or equal to 80. So a minus grade. Let's, let's run this again. And we have let's say
    marks let's say 64 below average. Okay, great. So you see this if Elif, Elif Elif else this
    can go as long as you want, depending upon your logic. So great. And further, you can
    combine several comparisons several billions, together with ands and ORS, and nots, whatever
    you whatever you like to like to do. Let me give you one more or one more beautiful thing.
    let's let's let's create an L without writing an else or let's let's just let's just write
    lF and implement ELS completely so we are not going to write ELS explicitly, but we
    are going to write a program that actually simulates ELS So let's see, if a equals let's
    say, three. If A is larger than 10, then Brent let's say larger than that. Now, we are not
    going to write else, but we are going to achieve the aerosport.
    Tell If
    not,
    a is bigger than 10. To see, then print you see that I mean, that's beautiful. If this
    condition is true, then go there. If this condition is false, then not have false is
    true, then you learn here. And you need not to write an expert if you want just I've implemented
    I have implemented l spark using l f. So see that. So l sparks so we are right now Spark.
    If A is let's say 13, then we will think okay, rather than just for fun, just for fun, okay.
    Okay, great. So, we saw if condition it's shorthand and LDAP structure in in a bit more,
    lengthy way. So in the next video, we will see if condition inside or in the body of
    another if condition, which is called a nested F. So hope to see you in the in the next video.
    In the last video we saw if lF structure, in this particular video, we will see nested
    F, or are simply called if inside the body of another F. So let's take an example to
    understand what nested if condition is simply we can understand if condition inside another
    if condition, that's all rest of the story is same. The way it works, it works even if
    it is inside the body of another if or or anywhere, actually. So let's say we have input
    a number, and then we check if x is larger than 10, then you move inside the if condition.
    If that is true. If that is false, then you are here, whatever you write here, it will
    work from here. But let's say x is greater than 10, then you print your number is greater
    than 10, your number is above 10. Let's say let's see Brent that now after this, after
    this statement, you move to the statement, and you just make another check if x is larger
    than 20. Now you see this if condition. This particular statement is inside this particular
    if condition, if this, this condition becomes true only then you dive in, otherwise you're
    not. So here you're checking if x is larger than 10, then you move inside and inside you're
    making more checks. So for example, if x is larger than 10, then you print or do some
    stuff here, then you apply Further more, more checks more graduality more, whatever your
    logic is. So let's say here you're checking if x is larger than 20. Now, if this condition
    is true, then you move here else now this else is of this if if x is not larger than
    20, then you move to this else l squat and you're here. So and we can have another if
    inside this particular F or an F inside this L sport and so on. So if inside an F is called
    nested if and we can have I mean deep structures, for example, if then something then if then
    something then if so maybe we can have a very lengthy structure if nested if structure depending
    upon the logic. So let's get ourselves comfortable. As always, by writing the code on Jupyter
    Notebook because that makes much more sense. When we see things running on, on on the notebook.
    So let's say a is let's say again, and let's say we take some number and if a is larger
    than 10, then we say okay, Brent, larger than 10 and do more stuff, Brent. That's inside.
    If condition, okay, then then maybe we have another check if A is larger than 20 then
    say rent greater than 20 Yeah, greater than 20. And you can rent
    now rent inside the nested if, okay. Else rent l sprint, smaller or equal to 20, smaller
    equal to 20. And then brand, for example, inside the L spark of nested if that's it,
    and you can print here, brand outside all it's fine. So that's it that's that that's
    the structure. So let's see, let's give an input which is larger than, by the way, if
    input is not larger than 10, this if condition is false, then you directly dive to this print
    statement and all this structure is not going to be executed, this is this complete thing
    is called the body of this if condition, and the body will only execute if the condition
    becomes true, whether that condition is just a single condition, or you have a combination
    of a lot of comparisons and a lot of Booleans whatever, if this condition becomes true,
    whatever that condition takes form of, then Then and only then you dive into this part.
    And when you are in this part, then that's a whole new universe, then you're on its own
    in the new part, in the new part, for example, if this condition becomes true, then you are
    in this part, that's the body of this particular if condition, and that's the body of the else
    part, see the the body of the top if condition has this kind of alignment, all the statements
    that are in the body of if condition, they start the same alignment, and all the conditions
    all the statements that are in the body of this particular if condition, they have their
    own alignment, and this indentation is necessity just to define, for example, which statement
    is in what kind of block for example, if I just press a tab, then another tab, then this
    print statement is in this L sport and this is the indentation that is defining the placement
    of this print, if for example, I press I align this with this, this particular structure
    here, then this print statement is inside this if condition, this is the indentation
    that is defining the placement of different statements. And if the print starts from here,
    then it is completely outside of all if conditions it is like this way. So let's run this board
    and see what happens. Let's say we brand let's say we just cried a equals let's say 12. So,
    what do you think what should be printed, if A is 12 then first of all this condition
    is true. So greater than 10 will be printed inside the top if that will be printed, then
    this check will be executed and this condition will become false because 12 is not larger
    than 20 then you will go to the else part and less or equal to 20 this number this string
    will be printed and then inside the else part of nested if that will be printed and then
    you will be out of all if condition then outside of all F's that will be printed. So let's
    see whether whatever we have said is correct or not. So yes, greater than 10 inside the
    top if less than or equal to 20 inside the else part of the nested f outside all F's
    Yeah. So that's what the nested F is. And by the way, you can have you can have for
    example, more if conditions inside the nested ifs for example, you can have one more condition
    here, if A is larger than 30 for example, then do what then print it is larger than
    30 as well. And for the brand, maybe not necessarily that you always write print statements you
    can do any interesting stuff
    inside inside the nested if of nested if find and then you can write the else part of this
    particular if condition here if you want to or or whatever I mean you can have as hilarious
    structure as you want, but that completely depends upon the logic or you may have an
    if condition inside that l spot here for example, You can write an if condition here, if whatever
    that is also, that is also perfectly fine. So, if a is larger than 20, then you print
    this if A is larger than 30, then this, for example, and literally write the else part
    here else, print less than or equal to 30. And we can print inside the nested inside
    the else for all of nested if of nested if, okay, so, while you see that program, let
    me let me just scale it down so that you can see that completely see that program. I mean,
    yeah, it makes perfectly sense to me, for example, you take an input, if that is larger
    than 10, then you're here. If it is larger than 20, then you are here. If it is not larger
    than 20, then you're here. Okay. So let's say it is larger than 20. If it is larger
    than 20, then you are here further, if it is larger than 30, then you are here. Otherwise,
    you are here. And once and by the way, if A is not larger than 10, then you are directly
    here. Wow. So let's run this code. Let me just scale it down so that you can see it
    more. You can see more text. Let's see. So let's run this. No errors. Great. So let's
    say the number is let's say 25. So, what do you expect the result. So the number is 25
    is greater than 10 inside the top if it is greater than 20 inside the nested if it is
    smaller than or equal to 30. So inside the else part of nested if off nested if and then
    outside all the hips conditions. Great. Yeah. You enjoyed that. I enjoyed that. rate. Okay,
    so that's about the nested if one more thing that I have already told you, but just let
    me tell you the power of indentation. You are here for example, in this particular if
    condition, that's the if condition and that's the nested if, and that's the else part of
    this if if you move this L sport in in the indentation or the alignment with this if
    then this is else part of this if and this is not the else part of this If so, remember
    the power of indentation the this is the indentation that defines which part belongs to what what
    kind of block or structure in Python. In other languages. Sometimes, for example, in c++,
    they they normally use to write these curly brackets to define a block and their indentation
    doesn't really matter. But in Python, this is the indentation that actually defines each
    and everything. So, for example, this is a crucial example if this else just moves backwards
    and aligned with this f you get this else with this if these two if an L structures,
    this is still nested if without an L sport. And if this else move somewhere in between
    I mean this is not aligned with this if this not aligned with this if you get a syntax
    error because that is not a proper indentation. So focus on indentation that is really really
    important. Yeah, so although i have i've told you that the indentation has already told
    you but I just I just found to make a slide over this elsewhere because that's important.
    Sometimes you may get confused whether this else belongs to this F or that F Well, the
    indentation defines this LS belong to what? Okay, I end this
    control flow indentation here. So from next video we are jumping toward loops. But before
    loops, I just want to I just want to write a lengthy program in F LS f there are combinations.
    I just want to write a Jupiter program for you to to get comfortable with F nested f
    the conditions that are ands and ORS and nots are stuff like so. So So in the next video
    we will be practicing more on Jupiter for if conditions and then from the next to next
    video. We'll be jumping toward loops, the very very powerful structure. Okay. Hope to
    see you in the next video. Okay, so let's just practice this if condition a little bit
    more in this particular video and we are going to achieve particular tasks. So let's design
    some task here. By the way, this has comment, comment, comment is, it starts from a hash
    symbol. And that's a statement that will never be executed. This just describes your code,
    for example. So like it, like, it is not there. But it is there as a text, but not as a code
    file. Like hash sometimes represents. Comment or description with a single line. If your
    comment goes on multiple lines, it is good to write a multi line comment. So that's single
    line comment, for example, single line comment, the multi line comments, they start with three
    quotes, and then end with three chords. So whatever you write inside, in these, in this
    particular block, that's a multi line comment. So let's describe our problem in this modal
    line comments, because that's the problem in form of text. And then we will be solving
    that problem using using the code. So that's just description of the problem, let's say
    user will enter of loading point number. Number, let's say 230 8.915. Let's see. Okay, your
    task is, is to so let's just adjust more readable, your task is to
    find out the teacher integer, portion, integer portion, before the decimal before the point,
    let's say for the for the point, in this case, in this case, it is 238. And then,
    and
    and then check whether if that teacher portion is and even number or not. So just print yes
    or no. So print even if it is even number, otherwise, print odd. So that's the that's
    the problem statement. That's the problem that we are going to solve. And this is just
    to commit now we are outside the command that's a multi line comment. Yeah, so how to how
    to solve that problem? How to solve that problem? So let's start solving this problem. I'm going
    to spend some time on this program just to get comfortable with the if conditions, let's
    say let's say that number is x is input, let me convert that input
    into our
    real number. That's it. Okay, we're just assuming that the user will enter a real number. It's
    real number. real number might be I mean to 38.0, that's a real number or 238 itself,
    that's also real number. That's okay. But we're not assuming that the user will enter,
    let's say some characters like ABC or stuff like sort of just just assuming that. Okay,
    now, assume that x contains real number, it may be an integer. By default, maybe user
    just enters 10. And that's it. So it may be already an integer, then we have to check
    whether that 10 is whether that 10 is even or not, or the user may enter 11.7, or the
    user may enter minus 34.7. Or the user may enter just zero or user may enter just zero
    point 30 535. There are a lot of possibilities that a user come up with this exe can contain
    any kind of number, and we have to check according to. So how can we move let us just see, whether
    that number let us just extract the decimal portion, the portion before point. Let's just
    extract that how can we extract that there are two conditions First of all, let's see
    if x is positive, then do what else do what? So let's try this structure first. The facts
    is positive, then what we have to do? And if x is negative, then what we have to do?
    So if x is positive, then what we do? We, we just so, what should we do? I'm just stuck
    here. How can we extract the, the decimal portion, the portion without this particular
    thing? How can we extract that? That's, that's tricky. That's kind of tricky. Yeah. So any,
    any ideas? I guess this? The the structure I have, I'm using the let us just first think
    that x is positive, just make our life easier. And then if x is positive, it's a positive
    number. How can we extract this portion out? Just the number that is below? That is before
    the decimal point, but what should we do? can we can we can we apply apply around function?
    Will that help? x? Will that help? helps. Yes. But no round function? So let's say y
    contains the rounded value of x then, so what? Then how can extract How can we extract the
    the the decimal portion, the portion the integer portion? Or maybe there is a function that
    actually round down? Let me check whether there is a function float or not? No, float
    is not a function, I guess. So let's say round x. Okay, now y contains the rounded vol value
    forever the Xs we are now assuming that x is positive, okay, then what? Now, if, if
    y is larger than x, that means we moved up. Okay, we moved up, the round goes up. In that
    case, what we do is we just subtract. So the let me so we just subtract the integer portion.
    So the let me in teacher portion, let's say that's our variable name, then the integer
    portion is simply y minus one is that correct? Is that correct? If y is larger than x, then
    integer portion is simply y minus one. For example, for example, just Just think about
    it, if When, when, for example, if the value was 29.6, and the rounded value will become
    30, so 30 minus one will be 29. There is what we are what we are interested in. So, yeah,
    so otherwise, if for example, else, else, if y is not larger than x, then y itself is
    an integer portion.
    Y itself is an integer portion. Is that correct? I mean, is that making sense to you? That
    if for example, if if x is larger than effects, larger than if the rounded value of x is larger
    than larger than x itself, then we just subtract one and we get the proportion. Otherwise,
    the rounded value itself is the portion, just just let's just run this, run this code for
    now and check whether what whatever we have done so far is correct or not. So after that,
    just print, let's say the integer portion. And teacher portion, let's just print that.
    Okay. So enter a number. Let's say the number is, let's say 25.3 45.367. Let's say, obviously,
    the integer portion here is 25. So let's say let's see our program returns 25. And now
    Oh, the result is 25. magically Oh my god. We found 25. Let's run it again. Let's run
    it again. Just to see. Okay, let's run this again. And order this time let's give it to
    45.8. Okay, the integer portion is 45. But when we will round We will get to 46 and 46
    minus one, we will dive into this particular if condition. Let's see. All the result is
    45. We are we are still moving very bill. Great. That's, that's great. So, okay, let's
    play with it. Let's, let's give, let's give 0.2 the result should be zero, it is zero,
    right? Let's run it again and give it let's see, let's say four. That's it, the result
    should be four now, it is four. Great. So, we are working very well we have extracted
    the integer portion as long as the number was positive. Okay, right. What if the number
    will be negative? Let's say that was true, if that was true, so, that whole logic works,
    if x was positive, so if x is positive, then whole this logic just works okay, then else
    What should we do? If x is positive, then this logic works effects is not positive,
    then what will happen? Then how can we find out the integer portion because first we have
    to find out the integer portion and then we have to find out whether they are integer
    portion is even or not finding out whether they are indeed a portion is even or not might
    be simpler. But first, we have to find out the integer portion. So for example, let's
    check the behavior of round function on negative numbers, let's say around minus 9.3. So the
    result is minus nine. Okay? If we say okay, round, minus 9.6, the result will be minus
    10. So it looks like the same as working in the positive numbers. So round function is
    actually working roughly the same way it should work in the positive numbers. Okay. So what
    should we do here? Any idea? Maybe, maybe we first convert? Maybe you first convert,
    by the way? Yeah, maybe first convert the number, let's say y equals around x again,
    like before, but then what? Then what? So maybe this rounding helps the same way? Maybe
    the rounding helps the same way. We should extract this out from this here, because it
    is going to work in the else part as well, why to compute it, why white write this redundant
    code? So why is round x let's say then if y is greater than x, what should we do? If
    it is negative y is greater than then what would what will be the portion? It will be
    the integer portion will be portion will be what?
    y minus one or one? y plus one? Yes, you got the answer? That's y plus one. Great. And
    else I guess we have in future portion. Equals Whitesell, I guess, yes, I guess that's the
    that's the good. That's cool. I guess that's checked, by the way, but I guess that's the
    code. By the way, this else part is, this else part is same in both of these conditions.
    So maybe, maybe we can combine this code and write a more elegant code, but I guess this
    would work. Let us just print the integer portion, just to check whether we are working
    well, so far or not. So let's enter let's see 12.3 The result is 12th grade. So it did
    not change our previous I guess our previous logic. So let's say there is minus 9.8. Now
    the integer portion should be minus nine, oh, it is returning 10 Why is that? Why is
    that? Oh my God, this should be changed when it is round. It may go that way or when it
    rounds it actually becomes lesser than 10. Because when it rounds it goes up and it becomes
    lesser than a negative word. This condition should flip. Yeah. So we are making an error
    here. Let's fix that. Okay, let's run this again. And see Let's say minus nine point
    minus nine d 3.2. Minus 93. Great. So then we have let's see, let's run it again. Minus
    8.9. minus eight. Yes, we are working perfectly fine. Once we have integer portion with us,
    we just right here. At the very end if integer portion is your portion, remainder with two,
    if that equals to zero, if that equals to zero, Brent, even, otherwise, else, brand.
    Art. That's it. That's the whole program. Let's see. And let's see, how is it running?
    Let's say 22.6. It's even, let's say minus 87.3. That's odd rate. So you see the power,
    if condition and, and how can we think in writing these programs and stuff like so?
    That was a lengthier video, I know. But I guess you get a very good look and feel of,
    of if conditions and thinking and building logic and all that stuff. So in the next video,
    we will start loops. So that's a beautiful structure, hope to see you in the next video,
    the best way to understand loops is to think about in a repetitive structure or repeating
    structure. Let me let me give you an example. And they will, we will dive into this code
    in a while. The example is let's say a user gives you a number, let's say integer number.
    And you want to print all the numbers till that number, let's say you start from one,
    and you keep on moving and printing all the numbers, as long as you reach that number.
    So for example, if user enters, let's say, five, your goal is to print one, then print
    two, then print three, then print four, and then stops, then stop just or, let's say if
    user print, if user enter, let's say, three, then you print one, you print two, and then
    you stop. This is easy. If user enters in n, we can just print, we could have written
    this thing, print. Brent, I, let's initialize a variable by with one, Brent I, and then
    I equals two i plus one, or in Python, we can write this quickly as i plus equals to
    one that means I
    that means in I store a plus one, this is the short form of writing this. And then after
    that, you just apply an if condition. For example, here, you can apply an if condition
    and say, Okay, if I is smaller than n, you keep on printing, and after printing, you
    just increment again this, then check the if condition and keep on moving. Well, that
    is visible if n is five, or n is three, what if if n is let's say, if t 1000. In I mean,
    you're writing all that structure again, and again. And again. I mean, that's a lot of
    code. Well, the loops are just a solution for this kind of structure when you want to
    perform the same kind of task again, and again, the loop gives you the facility to do that.
    For example, let's just consider the VI loop. This is again a condition similar like a condition
    in if condition like an if condition, you evaluate this Boolean expression, then that's
    an expression that results a boolean value. While this condition is true, you will stay
    in this block and after executing whole block once you check this condition again, if this
    condition is again true, you will dive into this block again. Then check the condition
    dive into the block then check the condition dive into the block. As long as this condition
    stays true, you stay in the block you you move inside the block. Once this condition
    is false, then you exit this while loop then the loop terminates and you move on to the
    further processing just like an if condition just like if conditions if if the condition
    becomes false, you accept that if condition and you can move on, moved on. So in this
    particular case, for example, if n is five, let's say if n is five, user give an integer
    number that is five I is equal to one, now one is smaller than five, the condition is
    true, we move inside, you print I, the value of i is one. So that's what you print, you
    print one, then you change a, you increment i with one, that means i equals i plus one,
    so I becomes two. Now the body of the loop finishes, that's whole body of the loop, the
    body of the loop can have many, many statements, a whole block of code. Once I becomes two,
    you move on and you check, okay? Two is smaller than five, yes, it is true, you move inside
    the block again, you print two, then you update I, the loop body finishes. Once the loop body
    finishes, you go and check the condition again, whether that condition is still true or not,
    it is still true i is three i is three is smaller than five, yes, you move inside, you
    print three, you update, I, you check the condition four is smaller than five, yes,
    you move inside you print four, and then you update I and then you move on now five is
    smaller than five false. Once the condition is false, you will not dive into the body
    of the loop, you will exit the loop and you will print done. And that's it done. So this
    loop becomes very, very, very handy. In in, in, in applications that have representative
    structures. And in most of the interesting programs, most of the interesting problems,
    these are the loops that play a very huge role. So let's go to Jupiter just to get our
    hands, get our hands on this loop. For example, let's say x is again, that's the end or n,
    let's take n and is in input. Let me make this a little bigger, just do. Let's say that
    input and input is a number, let's say n i is your surgeon, let's say let's say one,
    while I is smaller than n, you may have written this parenthesis just to just to create the
    readability just to make readability. And otherwise I mean, this is also Okay, that's
    perfectly fine. If as long as I is smaller than n, keep doing the following you what
    you do is bring, for example, the square of I paint the square of I, that the square of
    it, let's say, and then you say, Grant, for example. This is a question number. And then
    you just print I, that's the iteration number I have the loop.
    That's the equation number I this is just the spring, this is just a string. And that's
    our variable, its value will be printed. This print function takes as many arguments as
    you pass. So you can you can write a comma here and continue whatever you want to print.
    That's very flexible function. Okay, then what you do you say, Okay, I plus equals to
    one. By the way, this i plus equals to one is the same as i equals i plus one. You see,
    I have just commented here just to explain what this is doing. If I just write i equals
    i plus one that is also that is also correct in Python, but that's kind of shorthand. Okay.
    And that's it. Now, again, when I de indent, I'm outside the loop, let's say sprint. Loop
    done, for example. So that's the code for example. So let's run this code. Let's run
    this code. For example. Let's say n is equal to five, then we have five. So this is one,
    this is the aggression number one, then two square is four, this is the aggression number
    two, then three squared is nine, the aggression number three, then four square is 16. This
    is the iteration number four, and then the loop finishes. That's it. That's the first
    snapshot of the loop. We will continue from here onwards in the next video and I will
    show you more and more flavors of this loop. So hold on and wait for the next video. Okay,
    in the previous video, we saw a while loop and we saw one. One program related to while
    loop, just printing Just printing a bunch of numbers till a particular number. Well,
    when you are inside the body of the loop, that's a whole new you can write whatever
    you want to write, for example, you can you can apply an if condition inside the body
    and check that an at each iteration a particular decision should be made or not. For example,
    in this particular case, I'm going to print I whenever I is an even number, so, I is some
    number if it is even then printed, else pass this pass statement for example, is just a
    statement of saying that do nothing It is just a shortcut of writing do nothing we could
    have we could have omitted the whole else part along with this pass and still the code
    is equivalent but sometimes writing this past make the code readable just so so writing
    this boss statement just means do nothing and just move on. If we omit else statement,
    and we omit this boss, that's perfectly okay. So, for example, let's try it on the score.
    Let's say n is let's say n is five i equals one one is less than five Yes, one is not
    an even number. So go to the else part else means boss, which means go on and then increment
    i this print statement is outside the loop this is this is aligned with this while it's
    not inside the body of the loop otherwise, it should have been intent indented inside
    now i is incremented I becomes to now move back to is smaller than five years. Two remainder
    two is zero Yes. So brand two, so two will be printed. Because if executed else will
    not execute and I will increment because I is not inside the if condition it is inside
    the body of the loop. So I incremented I becomes three you go back, three is smaller than five
    years. Three, remainder with two is zero false. So pass i i plus one, so I becomes four, four
    is smaller than five years for remainder two is zero, yes, so Brent four. So else will
    not execute now increment i, once you increment i you get, for example, I equals five, now
    five is smaller than five false, so you go out of the loop and you print down. And that's
    what this code is. So, you can have if condition inside the loop, you can have nested if inside
    the loop
    you can have loop inside the loop nested loops, we will see examples of nested loops as well.
    I mean, that's that's all allowed are sometimes rarely required. Okay. So, next there are
    two important statements that are there, one is break one is continue, I want to focus
    these statements because they have a deep link with loops. A break statement where ever
    written inside the body of the loop tells that exit the loop immediately whenever this
    brake is encountered, whenever this brake executes, it exits the loop immediately and
    brings you outside the body of the loop. That's what it does break. So for example, if I becomes
    if I becomes divisible by 17 and the remainder becomes zero, you will print a break and then
    when this break statement will execute you will exit the loop immediately regardless
    of what is the value of AI What are other states wherever break exits the loop Okay
    great. Now, the continue continue statements continue statement wherever encountered continue
    brings the next iteration loaded regardless of the remaining remaining statements in the
    loop for example, when this continue will be executed, no matter how many statements
    are there onwards that are there, in the body of the loop, the loop will not finish its
    iterations iteration by going through all the remaining statements, but it will start
    another iteration immediately. So continue basically skips the remaining body of the
    loop and starts another iteration. Here I have written this. true true means while true
    means always run. You might be thinking always run it's an infinite loop will it will it
    when we will exit the loop because this true statement will always stay true. We're not
    changing this true anymore. There is no condition here. That's true. While true means always
    go inside the loop but once where whenever this Break his encounter, you're outside the
    loop right away. And this break exists, the loop does continue skips the remaining remaining
    portion of the loop body and starts the new iteration starts another iteration. So this
    continue means start another iteration immediately skip the rest of the stress of the statements.
    So the rest of the statements inside the loop body. Okay, so let's just practice this break
    and continue with just just in Jupyter Notebook to get a better look and feel of the loop.
    So let's say we have, let's say again, let's say n equals let's say 10. Or we might have
    taken that as an input, let's say n is equal to 10. While true, which means keep moving,
    it might have taken some value here, I equals, let's say one, while true, if I remainder
    with, let's say, nine, if that is equal to zero, then just break the loop tells ELS.
    Else, what you do is really you increment a else what you do is, if I is if I is not
    divisible by nine, then what you do is i equals i plus one, that's true. By the way, previously,
    we we have written this way. So either way is fine, whether you write a short form or
    this form, so else this okay. And that's, that's it, the loop finishes. That's the loop.
    After the loop, you just write Okay, print, the loop is done. So let's see, what's the
    output? The output is done straightaway. And the reason is, why it is Oh, one is not one
    is divisible by nine, only then you could have break. While true. Why? Why the loop?
    Oh, it does not print anything, we could have printed some statements so that we know that
    we went inside the loop or not. Okay, so inside, if so, for example, Brent.
    Inside else. So let's run this again. Oh, okay, great, inside sales, inside sales inside
    sales inside rails, the first time it go inside, if that time it breaks, and it goes out and
    pants down. That's what this break statement does. So let's see an application of continuous
    statement. That's for example, just copy and paste that code into another cell and see
    how this continue works. So, let's say we have a loop like so. So, what we say is like
    this, if I is nine is not equal to zero. If this is the case, if I is not divisible by
    nine, what you do is you get take i plus equals to one and then continue continue to the next
    statement. And whatever else you write here for example, brand something brand something
    else something else whatever that is going to be printed and what wants to continue will
    will be encountered whenever this eye is whenever this I divisible by nine is not true. If I
    is then you continue once this AI is divisible by nine for example, then you will not follow
    then you will not dive into this if condition only then these two statements will be printed.
    Because this this continue will not allow anything further that should happen. And once
    these are printed, let's say we break our loop right there, let's say so if for example
    for the very first time one is not divisible by nine, so I equals two. So continue these
    three statements will not be executed the next loop the next loop. The next one If condition
    becomes false, this continue will not operate, and then we print this statement, then only
    then we will print this statement, and only then we will break and we'll exit the loop
    and print the data. So let's print here. Brent inside, if so, let's run this code, let's
    run this code and see what happens. That's the good
    I should I should just yeah, NASA better font, let's run this code. So, when the code is
    run inside if inside if you see when you when you are inside if when you continue when when
    this is the body of if condition when if condition completes, it should print these two things,
    but continue is telling the cursor to go back to the next iteration and move on. And once
    this if condition becomes false, only then you get this distinct printed this thing printed
    if this break was not there, you do you then again was going to the while loop and you
    will be running an infinite loop and then you have done so that's what this continue
    and break does. So, in the in the in the very next video we will see another kind of loop
    here we saw the while loop in the next video we will see a for loop very powerful and very
    famous kind of loop for it does almost the same stuff as while loop while the while loop
    runs based on a condition they fire the for loop it runs based on contracts a counter
    loop that many times it should run and so on. So we will see the details of for loop
    and the application The for loop in the next video hope to see you in the next one. Okay
    in this video we are going to discuss for loop and other kind of loop in the previous
    video we saw while loop although most of the stuff almost all of the stuff can be achievable
    through while loop and sometimes it becomes handy to apply for loop. In this particular
    example, I'm going to populate a list. So before actually moving towards for loop let's
    see very shortly what a list is, although we are going to be or we are going to explore
    this lesson in much more detail when we will discuss the data structures module but just
    for the sake of example, a list is a collection of different kinds of elements for example
    234, that's a list of three elements. So two three and four the list can contains different
    type values, for example two 3.4 and stuff like so, we can access different elements
    for example, L of zero means the very first element the indexing This is called the index,
    the index starts from zero then index one is so if we print for example, Brent Elif
    zero the result will the result that will be printed will be two similarly we can append
    more values inside a list append let's say 53 and list after this append operation, the
    list will be having these values 234 53 we can remove delete, update and do a lot of
    stuff we will see lists in detail, but just for this example, just think that list is
    collection of a lot of elements and we can add insert more elements we can delete elements,
    we can change elements and so on. Or we can just initialize the list with just an empty
    list and start inserting elements one by one and expanding that list. Okay. Now, this is
    an empty list for example, and four is just a variable for i in this range isn't it greater
    range then means sequentially give a number one by one starting from zero start from zero
    a gift num give numbers one by one for example, first time give zero I will contain zero second
    time give 1/3 time give two and so on after every equation the range will give another
    number as long as the numbers they are smaller than 10. So, the last number that this range
    will return will be nine. So whatever this is written inside is not included and it starts
    from zero. So as long as I is in this range is lower than 10 as long as that you that
    the body of the loop just like the body of the while loop. So first time I will be zero
    and zero is smaller than 10 Okay, you print i i plus one and abandon the square of that
    in a list. Then next time this range will automatically return the next number into
    I. Now next time I will contain one next time I will contain two Next time I will continue
    In three, four or 5678 and nine, once the value of AI becomes nine, that's the last
    iteration of this body of the loop. And after that the loop finishes. So let's just write
    on this very very first time I will be zero when the loop enters its body very first time
    I will be zero and one will be printed because we are printing i plus one, at that time the
    list and the empty list will be having one number which is zero square. So list will
    be having just one number zero, because zero square, so, next time I will be one and we
    will print two and the list will contain one square which is one, next time I will be three
    we will I will be two we will print three and we will be having a square of two which
    is four, and so on till so until 10 here, when I will be nine we will print print 10.
    And in this list, we will be having nine square which is 81, I guess, and after that the loop
    finishes and we will be out of this loop.
    Okay, let's see this. Let's see example of this in, in Jupiter just to get more comfortable
    with with list as well as the for loop. So let's see, let's say we have an empty list,
    let's say an empty list. Just to consider a list like this L is just a variable, you
    can write another variable a name, that's a variable name L. Okay. So for i in range,
    in is a keyword range is a function in is a keyword, i in range. For example, let's
    say then, what you do is you brand, your brand i plus one or whatever you want to do, that's
    the body of the loop, and Eldad a band, that's a function of the lists, we will see that
    in detail in the data structure sessions. Okay, and that's it, the loop finishes. When
    you finish the loop, just print the whole list. So let's print the list. And you can
    see the result 1-234-567-8910. And that's the these are the values in the list. As as
    I mentioned earlier, all the little the values. By the way, this range function actually,
    if What if we want it to jump more than just one, for example, b we want it to start from
    zero, it reaches 10. And let's say we want two jumps to be taken as two rather than one
    and one. So the very first time so that's the start location. That's the end location
    which is not included start location is included and location is not included. And that's a
    step size. So very first time I will be one you move inside, then a jump of two will be
    taken the next time I will be so very first time the AI will be zero, then you move inside
    then the jump of two, then you move inside then a jump of two then you move inside as
    long as you stay smaller than 10 you will move inside the loop body of the loop. So
    let's see what now printed let's print just I rather than i plus one there was an error
    was the error 00 the range function does not have colons, it has actually commas. Sorry,
    my mistake. I was just a MATLAB user one. So MATLAB actually has this colon things.
    So I was just confusing MATLAB notation with this. Okay, great. So so first time i was
    zero, next time a jump of two, I becomes two. Next aim to jump off to AI becomes four, then
    I become six, then I becomes eight. And next time I becomes 10. But 10 is not included.
    So you're out of the loop. And that's the squares that you got. It is not necessary
    that you always start from zero, you can start from one and you can j take a jump for example
    the jump of three. And it's not necessary that you just reach them you can reach for
    example 20 it's up to you it's completely your choice. And in that case, you have this
    kind of vibrations. So this range function really is helpful for creating over over a
    loop body or a structure. Okay, great. So that was introduction of for loop and we have
    iterated here on on our list we just have actually populated a list using for loops.
    Okay In the next video we will see more details of this for loop and more fun stuff. Okay,
    hope to see you in the next video. Last time, we saw four In the last video, and magically
    this else has something to do with for loop in Python. Well this else clause makes sense
    for F. But in for loop it hardly makes sense. But let me let me let me try to make sense
    of else clause for follow there is an else part of for loop as well in Python, not in
    other languages. I don't know any other language that has this L spark maybe there is some
    but I don't know.
    So this else part in Python, particularly in follow, this else part or else that was
    blocked will only execute if four completes its iterations. For example, this is a set
    a set like a list is is a collection list is defined by square brackets set is defined
    by curly brackets, the set is just similar like the set in mathematics, we will see the
    set lists tuples dictionaries and many of these data structures in detail in data structures
    portion, but just I have introduced this, just consider this set has three elements
    Apple 4.9, and Jerry. Apple is one object or one data. 4.9 is one data, which is a floating
    point data and Jerry is one data which is a string data. Okay, so this S has three elements,
    three different elements. So now for x in this set, as long as x is in the set, the
    very first time the x will be Apple, so it will print Apple, next time x will contain
    a 4.9 as long as so I create over this set, as long as x is inside the set big elements
    one by one, and just print them all. Okay, we expect that when x is Apple, when the very
    first time x will be Apple, it will print Apple next time x will be 4.9 it will print
    4.9. Next time x will be cherry it will print cherry, and the loop ends because there is
    no item in sets to iterate over. Because the loop finishes it's complete iteration there
    are expected three iterations and the loop finishes those now the else part will execute
    and you will say okay, loop completed. So iterations. Well, you will be wondering in
    what case the else will not else will not execute. If you apply any brake statement
    inside the loop body, which means you forcefully you forcefully remove some of the iterations
    that were going to be executed but the loop did not complete it did not complete citations,
    then the L spot will not run. So let's see an example in in in Jupiter to get a good
    grip on this else. Okay, let's define a set S. S is a variable name. You can have any
    variable name that say it Apple, or let's say 4.9 I guess and then we was having, let's
    say, Sherry, if if these Spelling's are correct, I guess jelly. Okay, then for x in PES, as
    long as x is ns Brand X. Fine ELLs rant, when you finish the law terminates with success,
    or all iterations it completed all its iterations. And this is a statement that is completely
    outside the loop. side the loop, so let's run this. So you can see Apple 4.9 cherry
    loop terminates with success outside the loop. Okay. Now you might be thinking in what case
    this else will not execute. Okay, if, for example, as long as x is an N, if I say okay,
    let's say I take a counter here, I equals one, that's a counter, let's say, and every
    time I just increment i, i plus equals one, and then I check if i is equal to three. If
    y is equal to three, then just break. Let's say
    else just for readability else was now this else is else of this four. And this else is
    else of this if and this POS statement is just a statement for doing nothing. Now what
    you do when is equal to one you Brent this i plus equals I becomes two two is equal to
    three false, so you pass you move on. Next time, x will print 4.9, I will become three
    and three is equal to three, that's correct, the break will execute, which means the loop
    should have one more iteration, but the break just disrupt that one more iteration that
    should be there, because the loop could not complete its iteration due to this certain
    condition, this else part of the loop will not execute, and you will go directly outside
    this loop. So let's run this code and see the result. So you can see this apple four
    by nine outside the loop. I would recommend although this else is there for for loop,
    but I would recommend to avoid using ELS in the beginning, I mean, you may be confusing
    this else By the way, there is a there is a mistake here, this l should be ended with
    a colon here, okay. So I would recommend to not use LS clause for a for loop in the beginning
    until you you really need it. Because you may confuse this else with the with the L
    of F condition. And you may think something else and the program behave in a different
    way. So either way, if you want to use LS LS for a for loop is there in Python. Okay,
    just one more example of for loop. And here we use dictionary, I'm introducing some data
    structures here just for fun, we will see these data structures in detail later on.
    So dictionary, that's a key value period like set, but one item is consists of two numbers,
    that's called a key. And that is called a value. That's a key. And that's a value like
    a dictionary, we have key and values. So now as long as x is an X, X represents two key
    and d is our dictionary and D off x represents to whatever value that x points to, for example,
    Apple is a key that points to 44. Cherry is a key that points to gain. For example, if
    we're ID, apples, apple, the result will be 44. Similarly, d of Jerry, the result will
    be game. Okay, so let's I create over this dictionary using this for loop. All am I showing
    you that this for loop is very, very handy of creating over different data structures
    and a lot of data and stuff. Whereas file while loop is more handy and checking the
    conditions and stuff. Although you can do all the stuff using while loop you can always
    stuff using for loop but one is better over the other insert in certain situations. So
    that's let's let's just run this for a dictionary. Let's say I have a dictionary D. It's defined
    like a set, let's say my key is a and my value is 10. Let's say my key is B and value is
    minus 19. And let's say my key is C and my value is let's say ABC, let's say that's my
    dictionary. So for x in the Brent the key as well as the value of that key. So now you
    can see the key is a the value of Stan The key is B the value is minus 90 in the key
    of C the values ABC. So this far loop is really really handy and iterated over a lot of data
    structures and stuff although it has other applications as well but this is handy. Okay
    great. So that's about loops for loops. And while loops These are two kinds of loops in
    important loop these are two important kind of loops and they are in
    Python, in the next video I will directly go to Jupiter and Jupiter notebook and we
    will be practicing for this for loops or while loops. We will be practicing the loops we
    will be doing actually examples of nested loops we will be actually solving a problem
    like we did in the if conditions we solve the problem Previously, we wrote a code for
    it. Here we will also write a code and we will be get a good grip on the loops. So hope
    to see you in the next video we will solve a problem in Jupyter Notebook directly. Okay,
    hope to see you in the next video. Okay, welcome back. In this particular video we are going
    to practice for loops are basically loops. So let's have a problem statement. First,
    what problem we are going to solve let's have comments. And the problem we are going to
    solve is let's define given a list of of numbers, numbers. For example, I II, let's say 124
    minus five, a 7932, like this, make another list making another list that contains all
    the items in sorted order from minimum to maximum, ie, your result will be another list.
    Like, in this particular case, we will be having minus five, which is smallest, then
    we will be having one, then we'll be having two, then we'll be having two, then we will
    be having two, then we'll be having three. So all items, but in minimum to maximum sorted
    order, then we having I guess, four, then we'll be having seven, and then we'll be having
    nine. So that's your, that should be your output in another list. So assuming this list
    is available to you, or any list is available to you assume this list is available to you.
    So how to solve that problem? Let's start. Okay, let's assume that the list is available.
    That's it, this is the list we are going to sort. Let's say this is available. Okay. Okay.
    So, what should be the logic? What should be the logic? How can we solve that problem?
    This is, this is an easy looking problem, but it is not so easy. Let us first right.
    Let us just simplify this problem to just finding out a minimum from the list. Let's
    say we are given a list and we just want to find out minimum number one a minimum from
    the list. So how can we move that. So let's say M is some number. So M is the very first
    value of the list, let's MSP our variable, let's say that's the first value. And what
    we do is for i in the for i n L, as long as I is an L, if I AI is smaller than m, then
    if AI is smaller than m, then m should contain AI. Otherwise do nothing. That's it. So at
    the end, rentas m, then this m at the end. So, Brent, the minimum number, that's great.
    So so that's the nasty, basically. So yeah, that's the that's how we will find out just
    the minimum value. So let's run this code. And the minimum is minus five available to
    us. What if we want to store the minimum value as well as the position of that value? For
    example, we not only want to just find out what is the minimum number, we also want to
    find out at what index for example, here 012, and three, at the third index, we found the
    minimum, what if we're interested in the index as well. So let's say for the very beginning,
    the index is zero. And then what we do is
    we moved on and we say, okay, we maintain a counter, let's say a counter is C equals
    c equals zero, for example, right now, and C, just plus equals to one, that's a counter
    and then this ID x is just that C, whatever that c is. So whatever that index is, when
    we find this C, that index is also there. So let's print the index as well as the minimum
    value. So okay, so at the position three, at index three, we found the minimum value,
    okay, now we have written kind of a code block that helps us finding out the minimum value.
    How can we actually how can we actually do how can we act? So the basic logic is you
    find the minimum value and swap the that value with the very first value, okay, great. And
    then move the loop next time find out the minimum value from the remaining list and
    swap that minimum value with the second value. Next time you find the minimum value, as long
    as the position and swap that with the third value and so on. So do that stuff and just
    rearrange the same list using this but, but how can the so that's the logic find out the
    minimum value. So happened with the first value and then start from two till end start
    from start from the remaining values, find the minimum so appid with the first value
    of the remaining list, then reduce the list step by step and you will be having a sorted
    order, but how to start with how to find out like this how to how to do that. So, any idea
    and we are going to so for example, in this particular case, if I want to swap the list,
    what I will do is I will say okay, swap with zero at the at the at the zero, so, I will
    contain a temporary variable, temporary variable will contain the value of zero, this zero,
    so what I will do is at least zero, right the minimum value and the minimum value. So
    at zero you write the minimum value, but at this particular index, from there, we found
    the minimum value, just place the just place the the value at the very beginning. So in
    after that, after that operation, the minimum will be at the first position, or the zeroeth
    index, and that value will be some minimum value will be swapped with the very first
    value. So let's run this code and see what a list looks like after that good. So you
    see, for example, the minimum value is swept by the first value, whatever the first value
    was, but we want to do that progressively for for the rest of the list, we want to find
    out the minimum and follow up with the first one for the rest of the list and keep on moving.
    How can we do that? So yeah, that's, that's, so let me define four. So let me first in
    depth a bit, let's say control right bases that will indent all my code. So for j in
    range, length of the list, whatever the length of list, let's say for G is that so what I
    do is M is the gf value the index right now is J and the C is also C is also the Convert
    C is also starts from J, okay, great. Now, we want it to start with two now we want this
    I to start from J and move onwards here. So let's say i in range, start from G and go
    till length of L, one by one, take the step of one. Okay, great. So what next? Now the
    value will be L of I, rather than simply L of I rather than simply I in that case, you
    do this.
    Okay, and the index is just C. Okay, great. Keep on keep on introducing this index again,
    after this loop, what you do is you pick the gf value, you slap the gf value with the minimum.
    And you do that. And that's it, you keep on moving and offer after the outer loop finishes.
    If you branch your list, you will be having the list sorted or at least we hope so. So
    maybe there is a bug in the code or maybe there is a problem in the code. But we hope
    this will work. What we are doing progressively By the way, this is a nested loop. This is
    a loop inside the loop and that's and then we have an if condition inside the nested
    loop. Loop inside the loop. Great. Let's see how it how it works. If there is no Oh there
    is an error length of range. Oh, we haven't write a colon there. Don't forget this colon.
    That's a problem. Oh, we have a sorted order. Oh my god. We have a result with us. You see
    the applications of this. Oh, one three is missing. We were is three, we have two threes
    Oh, the output we have written here is wrong, there is no two threes there is only one three.
    So you have sorted a list. If you remember, we have written a similar kind of code in
    the problem. So problem solving session very earlier, where we solve this problem using
    selection sort, but they are we just wrote a pseudocode. And here we have a code much
    simpler than actually the Python code. If the problem was just sorting there are built
    in functions to do that, but I'm just telling you how these loops and if conditions and
    all that stuff can be used to communicate with each other to match with each other to
    to actually perform a problem solving task when given a problem. Although we will see
    later on in Python, most of the problem solving tasks, I mean many more of them, there are
    a built in function for those that are available functions for those you need not write all
    that stuff, but to mastering to to master any programming language, you have to go through
    these constructs. So that for a new problem, or for a very large, complicated kind of problem,
    eventually you you may need these kind of structures with you. So mastering these structures
    is really essential for problem solving and programming in general. So okay, that's about
    the loops and if conditions and control. So, all of that, in the next video, I will I will
    start talking about functions. So you have seen this L e m data function, you have seen
    this range, that's that's function idolater. Although you have seen around function, you
    have seen def mode, you have seen print function, what if we want to write our own function?
    How can we do that? From the next video, I'm going to show you how can we write our own
    function? Wow, isn't that great? That's great. So hope to see you in the next video. In this
    video, I will talk about functions. A very powerful construct in almost every programming
    language. Python also supports functions. What a function is, let me let me describe
    the let me describe the need of the function by a scenario. Let me give you a scenario.
    The scenario is let's say you are writing a very lengthy program, the program requires
    to print particular messages whenever needed, for example, you need to print this particular
    message the task, the task was successful, let's say you need to print this. And then
    you have to print moving to the next task maybe to to inform somebody maybe in to inform
    your client. And then you have to ask, okay, send me the next task. Because I am done with
    the previous task, let's say you want to print this, or maybe you want to print more or do
    some more stuff. And let's say you want to do this again. And again, whenever needed.
    Somewhere, whenever you complete a particular task or something, you want to print all these
    messages, and then somewhere else, whenever a particular event occurs, you need to print
    all these messages again. Now one way to do that is to write just these print statements
    whenever needed in the program. One way is if you want to perform a task and the task
    has a lot of coding, maybe maybe maybe a very small amount of coding or maybe a very large
    amount or magnitude of the coding. In this case, we have just three statements, but maybe
    we have a task that we want to perform again and again and it is really a very lengthy
    task in terms of the coding.
    So, one way to do that is to just write all the coding in coding somewhere and define
    a function and that function means the function contain all the tasks that you need to perform,
    whenever you need to perform that particular task. Just in your coding, just call this
    one statement, just this one statement, and the whole task that is written under this
    under this content maintaining this as a heading that will execute automatically I mean, however,
    I mean, that task that is under this heading may be very lengthy may be short, may may
    be complicated, may be simple one or anything, but the need is we want to perform this task
    whenever we need. And we do not write to code this again and again we do not write to code
    we do not write to we do not want to write the same lines of codes again and again and
    again. And again in our program. Just write this particular lines of code once define
    a function, just like a task. Whenever you need to perform that task, just call the heading
    or the name of the function. And the whole task under that function will execute functions
    in almost all programming languages. They do that even in mathematics. They do that
    In Python, the syntax of defining function is you if you want to define a function, you
    have to first start with D E F meaning definition or defining, then you need to write the name
    of that function the name of that function name a function and name a variable has resemblance,
    I mean, the name of functions should be descriptive, it should, it should portray what the function
    actually is doing. So, it is good to write it is good to suggest the names of the functions
    that are very descriptive to make the code readable and manageable. So, here I have written
    the function name is sprint success, you can write any name, then you start parenthesis
    then you end parenthesis and then you write a colon like you have written the colon for
    if conditions are for loops or any other constructs. And then you do indent like the body of the
    for loop like the body of the if condition, this is the body of the function, body of
    the function is all should all be aligned, then you write all the tasks, all the coding
    that you need to be performed whenever this function is invoked or called, this body can
    contain if conditions for loops inside, I mean, this can have a whole lot of coding
    inside it. And whenever you will call this function, whenever you will type this command,
    wherever in your coding, the whole task under this will be executed automatically again
    and again whenever you like. So, let's take a look of defining our first function in Jupyter.
    notebook. Let's just I guess, yes. So, yeah, so, that's our notebook, we were populating
    that notebook. So by the way, if you if you want to know where this notebook is located,
    if I want to, for example, invoke that notebook again, when you will run your Jupyter Notebook
    from the Anaconda prompt, you will be having all the files that you are working on. And
    one file is for example, this you just click on that, and your file one or more files,
    whatever you want to open up that will open up in the Jupyter. notebook. Yes, so it is
    opening up, it's a lengthy file, so it may take may take a second. Okay. Let me just
    take a better zoom level, just to Okay, so we were working on that notebook, let's define
    our first function, let's say D, F, define. Let's say the function name is Brent. Success.
    That's a, that's a syntax, then press enter, Brent, I am done. Then Brent, send me another
    task. Let's see. And that's it. Let's say that's the, that's the body of the function,
    the body of the function here contains only two statements, okay, then you run this, you
    run this command, just like Shift Enter, you run this. So that
    it is it is reported in the symbol table, there is a symbol table inside the Python
    maintaining Python is maintaining all the variables all the function information inside.
    So once you run this cell, then the then this print success function will be registered
    to Python. So that whenever you want to call this function, again, it will be available.
    Now if you want to perform this task, let's say you want to perform, let's say you want
    to perform this task whenever you want. So you just call this function, this is called
    calling of the function. whatever I'm doing now, when success and that's it, you press
    Shift Enter, and the all the statements that are under this will be executed. And you do
    some other stuff, let's say three plus eight that is that is 11 do some other stuff. And
    afterwards, if you want to do the same process again, then you call this function again and
    all the coding inside the function will be executed it is very, very handy. If a particular
    task if you want to perform that task repeatedly, it is good to just write one code for that
    task in a function and then just invoke function whenever you need. It supplies a lot of managing
    power, a lot of debugging power if you have an error for example, inside the function,
    you just go to the code we just go to the code of the function itself and fix the error
    and come back You need not to you need not to go all over the code if you have not defined
    the function and you have called these lines of codes everywhere inside your main code,
    then it will become very difficult to handle And function actually provides a lot of a
    lot of simplicity of managing and readability and, and a modular approach in that sense.
    So that was our first. That was our first function. We will be talking about more, we'll
    be talking more about this functions in the next video. So hope to see you in the next
    video. The function name should be descriptive, that's okay. But it is further important sometimes
    to have a documentation of the function sometimes called the doc string, the doc string allows
    you to write the description of the function. But that description will never be executed,
    it will be available whenever you need help. Or you need to know what this function does.
    Sometimes it happens your function can contain a lot of code, for example, you have a particular
    function, let's say, fun, let's say it contains def, fun, and it does a lot of a lot of complicated
    stuff inside. And it is sometimes required to know what this function actually is doing.
    So this document string is one way of describing what the function is doing. You might be thinking
    that if you're writing this document string inside the where the where the coding of the
    function should be written, we should open up that the coding file and see what the function
    is doing, or should we actually open up this function implementation where the function
    code is written. And then we have to read what the function is doing. Actually, Python
    gives you another power. If you have written the document string inside, that should be
    a top statement before the first coding statement. Whatever description you want, as a document
    string, it will be available without actually opening up with without actually seeing what's
    inside the funk without actually opening up the file that contains the implementation
    of this function. Let's see, let's see. Two in Jupyter, notebook imore, completely whatever
    I'm saying right now. So for example, let's define a function. def print success. to let's
    say the function name, this function is print success to the function name is print success
    two, although it's not a very descriptive name, but the specimens are also not correct,
    but that's fine. Print success to here I just define a document Strank. The document string
    may contain maybe just in one line, or it may be a multi line, it is like a multi line
    comment, or maybe a single line comment if you want. But it starts with the three quotes
    and ends with three quotes. Let's say I write here this function is doing nothing except
    renting. message, printing a message, let's say full stop. And then I further define let's
    say I define more in saying that that message is
    Hello, let's say, let's say are any description you want for this function. Now, this is a
    document string, and it will be available whenever you need. Now here are the coding
    starts, let's say you, right according here, and again, hello, let's and you run this code.
    Now, let's say we are not seeing this function we are we are not available with this function.
    We are not available with the code of this function. And we want to know what this function
    actually does. First of all, we can just write if we write pri, and just press tab, the tab
    will allow us to access all the functions that are available with prefix pri. So let's
    say we go to print success, brand success. Brain success here brain success, as should
    be capital, Brent success, let's say so print success to let's say and we write a question
    mark in front of it, and then just press Shift Enter, it will pull the document string it
    will pull the document strength whatever we have written and we will get to know what
    actually this this is doing. So this document string actually does a lot of job further
    if we I mean this is this is kind of whenever we need to know what a function is doing.
    The document string is one way to just go and check what is what is happening. Right
    now this function implementation is in front of us But in several times, the function implementation
    will not be in front of us several times, we will be accessing functions that other
    people have written in their libraries. And we need to know what those functions are doing.
    So document string is one very, very healthy way of describing our function. And I will
    recommend to make your habit writing document strings, every time you write a function.
    I was telling you that if you write a double question mark, then it will not only pull
    the document string for you, it will pull the whole implementation as well. So now if
    you see you, they said the document string, and that's the implementation. So whole implementation
    will be available, if you want. And this is true for the functions that are that are,
    that are the functions that are third party functions, or some other person have written
    that function and so on. For example, you know, a function length, we call that function
    several times. So let's let let's, let's see, also the document string is returned, the
    number of items in our container, that length function is not written by us, somebody has
    written that function that's a built in function, by the way. And we can, this document string
    tells us, okay, what this function is doing, we don't have the implementation of that function,
    obviously, somebody have written that function. And, and if we write the double, then we should
    get an implementation as long as the implementation is not in c++, I haven't told you that a lot
    of a lot of implementation of Python itself has been done in C and some other languages
    have C mostly. So several built in functions, because of because of their speed, they are
    implemented in C, and if you, if you want to get their implementation, they get their
    code, the code will not be available for most of the functions. So that's so whenever you
    write a double question mark, and the answer is the same as a single question mark, that's
    an indication that this particular function is not written in plain Python, it is written
    in some other language and is used in Python. That's, in other words, the diversity or flexibility
    of Python, you can engage multiple languages inside, Okay, one more thing, I can write
    Help, help command and I can get this Brent success
    success too. And the help of print success to by just typing this help command. So, this
    help will tell us, you see the Help is telling us the document strike I mean, this help on
    this function, if and this and this is the function we have written, this is the function
    we have written, this function is doing nothing except whatever description we are giving
    there. If, at some time, if we are supplying this function to somebody, or making a package
    of a lot of functions, that we are writing these documents, strings will help to get
    to know how to use these functions. By just knowing the function name, we can, this document
    string actually tells us how the what the function is doing. While great Oh, by the
    way, we haven't called this function yet, we are just playing with the document string,
    let's call the function print. Now we know what the function is doing. let's print, let's
    call this function. And whatever written inside the function will be called See, this is only
    called this is just acting as a comment and it is basically a comment. Yeah. Okay, great.
    Stay with us. There is much more about function that we are going to tell you. Hope to see
    you in the next video. Okay, in the last video, we saw document strength. Or you might be
    thinking, what is power of this function, if it is doing some static task? Well, in
    this video, I'm going to tell you that the function can the coding or the behavior of
    the function can be dynamic, based on based on the arguments based on some properties
    that you will be defining at the call time. For example, the function has in almost all
    programming languages, the functions, the most interesting functions are the function
    that receives an argument. And an argument is just considered an argument just as a variable
    and performs its task according to that to that arguments. argument. Just take a single
    simple example. Let's say rather than having a function print success, we have a function
    print message, and it it prints whatever message it receives. And at the call time, for example,
    we call this function like so print message. And let's say we call this as, let's say,
    success. Let's say now success will be printed. Next time we call the function and we give
    another argument maybe in a string, let's say so 74 errors, let's see, that will be
    that will be printed or anything, I mean, anything that you supply will be printed.
    Wow, isn't that great? I mean one function. And you might be thinking the plain print
    function does that what's the power of this? Well, I'm just telling you the function of
    the function does not only contain one line, I mean, it can be a whole task depending upon
    this input argument. And the whole task will perform dynamically based on based on what
    input argument you are supplying there. You are noticing one one thing that I that I just
    forgot, what is that thing I define this function? I guess everything is fine. I just have just
    missed something Oh, document string, I should have written document string. Although document
    string is not essential. If you do not write document string, it's perfectly okay. The
    function will run but it's a good practice. It's an it's a good habit to always write
    a document string. Okay, let's see the power of input arguments by again, going to our
    good friend Jupyter Notebook. Okay, so let's see. Let's say we define a function define
    Brent grant message, let's say, edit receives an argument message. And this argument is
    just a variable, it's just a variable. And let's say we say okay, print message or further,
    let's say you say, if is in stance message spraying, if this is spraying, then simply
    then simply branded. If this is not a string, then just say okay, brand, your input argument
    is not a string. And then you say, Okay, here is what you have, slide. And then you say,
    okay, whatever you have slide, just see, okay, message. And that's it, that's it, that's
    the function, we might have written a document screen for it. The function rents the message
    supplied by the user, or brains, that message is not in the form of strength. While Don't
    worry, we have to see the strings in detail, we will see the sprint function in detail
    as well, because the sprint has a lot of lot to do with strings. So so just for now, I
    mean, that's our function print message, let's say if the message is of string type, this
    string does not good, this is this should be simply str this should not be that is instant
    steak like this, your input argument is not a string here is what you have supplied. Here
    is what you have. So here, we can, we can say here is here is here is the type
    of what
    you have supplied. And then we can just print the Type, Type MSC. So the goal here is to
    just create a function that prints a message if that message is in plain string form. If
    it is not a string, then it prints that okay, you're the whatever you have signed is not
    a string, it is not a proper message in string form. Let's say this print message function
    receives a string, let's say that's our logic or something. So let's run this. First of
    all, let's see what it does help rent message. So the function prints the message supplied
    by the user. We can access the same help by question mark if you want and it gives us
    the document string If however, we want The implementation as well, then we write readable
    code and implementation is also available. While grade Python is really great. Okay,
    let's call this function. Let's call this function, Brent, message. And whatever you
    want to print, let's say, this is the message. This is the message, let's say you want to
    print this. And this is the message that's printed. Okay, now, let's say you call this
    function again some time, and you supply 23. And it will say your input argument is not
    a string, here is the type of what you have supplied, it's an integer type rate, you can
    you can have, you can have, you can call this function in the following way, let's say you
    define a variable y, and the variable y contains
    Hello.
    Hello there.
    That's it, that's your, and then you called, then you call this function on y. And it will
    print hello there, because y is also a string. Great. So that's how you can you can you can,
    you can pass different arguments and instruct the function, how should it behave without
    actually writing the whole logic of the task again, and again, if written all the logic,
    once, actually, this is actually the logic starts from here. That's what the task is
    to, that's what the task you want to perform. And you need not write this again. And again,
    whenever you need this kind of stuff, you just call that function supplied arguments,
    and it will behave accordingly you want. Great. So you might be thinking, the function only
    receives one argument, maybe we want to supply more than one arguments, maybe, maybe two
    arguments, maybe three, maybe four, maybe five, and maybe we want to supply several
    arguments. And we want to do some task based on the values of those arguments, or those
    variables. So in the next video, I'm going to show you multiple arguments. Okay. Hope
    to see you in the next video. So in the previous video, we saw we can define a function, and
    we can supply input argument to it. And in this video, we are going to see that we can
    actually send more than one arguments to the function these arguments are just variables,
    these are just variables, whatever value we will supply to these dynamically, because
    Python is dynamic dynamically typed dynamically they are type will be defined. And for example,
    here we have supplied just two variables, and we just printed them, but based based
    on supplying more than one input arguments, and based on what logic we are going to perform,
    we can do anything, we can do anything. So guess by thumbs, allows us to supply multiple
    input arguments to a function and and we can, we can just perform all the tasks according
    to whatever logic we are going to do with that. So let's go to our friend Jupyter Notebook
    and see an example of a function with multiple input arguments. Let's say the function the
    B define a function, let's say, my power, let's say, my power, my power, let's say,
    you remember there is a POW function in in Python that's a built in function. I'm going
    to write my own function, let's say it contains a and b. Well, document string. My, this function
    computes
    power
    just like built built in power function. Great. That's the document screen. Okay. Now what
    we want to do is we want to print Okay, let's let's, let's create another variable, see,
    that is a power B. Okay, then we print this C, and we are done. That's it. That's our
    goal. So we register that function by just just calling the job by just pressing the
    shift enter in Jupyter Notebook. And now we check what this function does. Well, this
    function can be horsepower, just like built in power function. Okay, just to Just to remind
    you again and again, the importance of document strength, I'm writing this again and again,
    let's run this function, my power, let's say three ways to recover for illness. So the
    result is 81. Oh my god. So whenever, by the way, if you don't have POW function with you,
    although you have, you can you can create your function and whenever you want to use,
    you can use your function, not a big deal. By the way, what if you? What if you What
    if, let's say, you can, you can define a function with more than two arguments to find, let's
    say, display types. That's it, that's your function display types. And all you know,
    is our check arguments, let's say, check our x. That's it, that's your function, and A,
    B, C, D, let's say E, these are the input arguments. And let's say, at some tasks, you
    want to know whether all the five variables that you're working in somewhere, whether
    all of them are numeric values or not. If they're not numeric values, you're not moving
    on, and you're doing something because you were extra, let's say you're, let's say you're
    taking input from somewhere reading from a file or whatever. And you need to, you need
    to check before moving on whether A, B, C, D, and E, whether they are in sore floats.
    Otherwise, if if if any of them is not into float, then you're not processing, then you're
    not moving on, and you're going to check the input arguments again, and so on. These kind
    of functions are there because whenever you call certain, whenever you want to do processing
    on data, sometimes it is required to check the type of the data whether the data is supplied
    in a way that you were expecting and so on. So let's have this function check Oryx. I'm
    not writing document string here, I guess, I've told you enough to write document string
    again and again. So let's see. If is instance. A, if is instance int float? If that is true?
    And
    is it let's just have three variables just to just to focus on if is instance, a then
    B. and is instance see if all of them are? If all
    of them are? If all of them are integers or floats, then do something then let's say Brent,
    a plus b, plus C, maybe, or a plus b plus c, raised to the power to just print their
    square, let's say else are if they are if they are all integers or floats, then do some
    interesting task here some task. Otherwise, you can say okay, print,
    air. The input arguments are not of the expected. But it's fine. You have this function, let's
    say, let's call this function.
    The function was check arcs. So let's check arcs, check. arcs, check arcs, let's say three,
    four, or five. So now you have all of them are great. Let's say you have jet arcs. And
    you call this check ARDS.
    On,
    let's say, three, four, but this five is a string, let's say, Gee. Now we'll be having
    an error. The input arguments are not all of the expected types. One of them or more
    of them or whatever. Yeah one more thing the this function is expecting three arguments
    if you call this function by less than three or more than three arguments you'll be getting
    an error for example three four although this function is accepting three arguments, you're
    calling it with just two you're getting an error because you have not specified all the
    arguments that the function is requiring although the the arguments that you have supplied they
    are of the type that it is expecting, but you have not supplied the the number of arguments
    that the function is expecting. Similarly, if you call this function by more than three
    arguments, although it requires three arguments, you again will get an error, because it is
    expecting three arguments and you have not supplied three arguments. later on. In later
    on, we will see how to write a function that accepts a variable number of arguments, we
    will see that but right now, in this particular way, if you write the function, if you define
    the function in this particular way, you have to define the arguments the number of whatever
    the number of arguments it is expecting, you have to supply exactly as many. Otherwise
    you are getting an error. Okay, so that's about the multiple arguments. Okay, what next?
    Well, next time, in the next video, we will see that what is the what's the importance
    of order of these input arguments? What will happen if I just swapped message to win message
    one? Will that will that change the behavior? Or is there any order? With the first mess?
    The first variable, the second variable, third variable? Is there any ordering inside the
    input arguments? Yeah, there is. So let's see in the next video, in the last video,
    we saw, how can we pass multiple How can we define a function with more than one input
    arguments, it is important to know that the order of the input argument is really, really
    important. So whatever argument at the call time, for example, if you call this particular
    function, the name of the function is f, that's not a great name, you should have a name that
    a descriptive but I recommend write good names, let's say this is f, that's a function and
    the very first variable is C to the second variable c one, the third variable is C three.
    Now you let's say call this function like like this, let's say two, four and nine, what
    will happen is this too will be copied in C two, this four will be copied in this C
    one and this nine will be copied in this C three. Now, C two has a value two, c one has
    a value four and C three has a value of nine. If you change the symbols or the variables
    order here, whatever order you have written there, the first value that is passed at the
    call time will be passed to the first variable whatever the name of the first variable is,
    the second value at the call time is copied in the second symbol, whatever the name of
    the symbol is. So, this ordering is really really important. One way to work one workaround
    for this is at the call time, you actually define the variable names and their values.
    For example, you call you call F and you say okay c one has this particular value, but
    this way you need to know that there is the symbol name in definition is exactly c one.
    So, C one has this value, C two has this value, C three has this value, once you at the call
    time, if you have defined your variable names along with their values, then you are order
    free. Now you change whatever whatever if for example, you call this way c two is b,
    c one is a now no matter in what order you have called these,
    this C one is going to be copied in C one, the C two is going to be copied in C two and
    C three is going to be copied in C three for the functions that has many more arguments,
    it is it is good to it is good to call the function in this particular way. If there
    is a chance that calling a function in a different order may may may become confusing and stuff
    like so. This actually gives you more grip on this ordering issue. if if if you're if
    you're happy with if you're very smart and When you say Ok, I will always supply in a
    particular order, I will always read the document string first, and then I will call that function,
    that's okay. Otherwise, this is also a feature that is available at the call time, you assign
    the values of the functions that are there at the definition time. And now no matter
    in what order you are calling that function, see one occurs at third position c two occurs
    at first position, the relative values will be copied according to their names. So and
    that's a good feature. That's a very good feature. Let's see, for example, a running
    example of this in Python. In Jupyter, notebook, okay, define, let's say function f, let's
    say it receives a, b, and c, let's say three values. And let's say prints. A, is that's
    it, Sprint, a, is a. And you'll say okay, B is B. And then it prints Okay. See, C, C
    is, whatever the value of c is, that's the C, okay? Now, let's call this function f,
    with, let's say, two, three, and game. So, they will say, okay, a is to B is three, C
    is game, fine, great. Now, this tool will be copied in a no matter what if we if we
    change this, if we change this calling order, for example, if we if we change this order,
    we just we just moved to we just moved to this particular order, we just say okay, this
    is three, this is game, this is to be called like, so now three will be copied in a game
    will be copied in B and two will be competency. And that, if if if that is the behavior you
    want, then you are good to go. Otherwise, it is it is handy to call the function in
    the following ways just fix, okay, a is a is to fine. B is three. And C is let's say
    again, if you want these numbers, now, if you call a function like so, that will happen.
    Now, if you change the order, no matter what order of add the calling time you come up
    with, it will stay the same. For example, you go and say okay, C is at the first position.
    And a is at the second position, let's say two, and B is at the third position three,
    the output will stay the same. And that's a, that's a beautiful, that's a beautiful
    thing. So that's one way of handling with the order. If you if if you think at call
    time it is important to define the variable names, but it has one problem that you need
    to know you need to know exact variable names. If the variable name is C one there, you need
    to know what it's see one, you need not to I mean the C one matches with C it must match
    with C one, C two must match with C two and so on. So you need to know these names. Okay,
    great. In the upcoming videos, more features of functions are are going to are going to
    be discussed. So stay with us hope to see you in the next video. So we in the last video,
    we saw the ordering of input arguments in a function.
    And we saw a fix to it. I mean, if you if you if there is a chance that you may miss
    a proper order, there is a way to fix that we saw that in the last video. Here, we have
    another another thing to discuss this x variable x input argument This is the variable that
    is defined inside a function although the value it receives is copied from somewhere
    else, but it is defined inside the function that is also the function variable or the
    or the variable that is in the scope of the function inside the function in the body of
    the function something like so it may be handy. For example, let's say you want you you compute
    something you do some processing on your inputs. And whatever the result is you save that result
    in another variable. And let's say now you need the value of this variable. to do some
    further process, let's say, what you do is let's say in a call time, that's let's say
    this is the this of the function and say, This is the complete function. And let's say
    a is equal to 12. And B is equal to, let's say seven. And let's say you call the function
    add a, b, now the value of a will be copied in x, the value of d will be copied in Y,
    okay, and now, you need the Sum of a and b, to be received here, in a variable, you want
    a variable in which the results should be saved. For example, let's say a variable is
    D, let's say, and then you want to do some more processing on D, let's say d doublestar
    five, mod three, and maybe you need to apply an if condition on that if that equals to
    zero, then do some stuff otherwise, so let's say you need this variable out, what will
    happen is this C variable is not accessible outside this function. And the reason is the
    C is defined inside the function when the function body completes its execution, the
    C is lost sees no more available, C is defined when the function call has been made, when
    the when when you're executing the statement C is defined and a memory location was created
    in a C sometimes called the function space in the memory or process space that is created
    in memory. But once all the body of the function executes all the functions that were inside
    the variable they are lost, what how can you How can you receive this value? How can you
    receive the value inside see outside this function? So, that is, that is question in
    this slide, how can we do that further,
    this particular function can access all the variables that are not defined in this function,
    but that are available outside this function and are defined already. For example, let's
    say I have a function, f. And the function is let's say I have a function f. And so if
    this function is defined, like so f, let's say F is your function, and it has to find
    like D, E, F, and that's it. And here it prints let's say, some variable, let's say a. Let's
    now now you know this a variable is no longer in F not even defined in F, but as long as
    this a variable is defined, before calling F for example, that's the cell where we are
    writing the code and we say okay, a is equal to seven, and then we just call this F, because
    a was available before calling f a will is accessible here. So, the functions the variables
    that are available before the call, they are available inside the functions, but the variables
    that are defined inside the functions, they are not available outside. That's the problem
    further, if we define this ad here is equal to two now, this a is sometimes called the
    local variable or the function where the variable there is local to the function. Now, this
    a is is is defined inside the function and all the accesses to a will access this value
    to rather than the sound considered sound has a separate location in memory, and this
    too has a separate location and memory, both have names a, but this a will only be referred
    to when the function is executing, after the after the execution of the function completes
    this has gone from the from the memory and this will still be available, the seven will
    still be available. So it is good to know and by the way, if a was not defined here,
    and you still call F, then either you will be getting an error, or this a might be a
    global variable or available in some package that you have already loaded or stuff like
    so, in that case, this eight will be accessed if it's a global variable or accessible. So,
    it is good to know the the scope of the variables inside the function because when you're calling
    them what functions if this if x is already defined, for example, if x is already defined
    like 34 and then this x is 34, as long as this x is not defined here, if x is defined
    here, this is this x actually is the local copy and that will be accessed inside the
    function. Once the function is gone again x will be 34. So, it is good to know the local
    copies or or the function space itself. The but but the problem here is how to access
    them. This variable the value of this variable outside the function, because this is completely
    defined inside
    how to access that? Well, well, there is a fix, and that fix is called the return statement.
    If you write the return statement, for example, you return this value. So x plus y, you might
    have saved these values, you might have saved these values, for example, C equals x plus
    y, that's okay. And then you say, okay, return, see, what will happen is wherever you have
    called this function, d equals add, let's do three. Now, this value, this value C, which
    in this particular case is five, that value will be returned in D, and all the properties
    of this variables are returned in D. So just like the C is copied in D, and this is available
    further, whatever you want to do with this D. Okay, so yeah, so return statement is there.
    So, in the next video, we will actually code this in Jupyter Notebook and see the return
    statement running and we will see the scope of the variables and all that in Jupyter Notebook.
    So hope to see you in the next video. In the last video, we saw a scope of a variable particularly
    if a function if a variable is defined inside a function, is it accessible outside the function
    and if a variable is defined outside the function, is it accessible inside the function and vice
    versa? and so on. So we discussed those kinds of things, which is sometimes called school
    scope of a variable. And further, we discussed what if we want, what if we want a value of
    the function that is computed value value of some variable or some result that is computed
    inside a function? What if we want that to be accessed outside, outside the function?
    So we discussed that in detail in the last video, so let's see all those concepts in
    a running form in Jupyter. notebook. So let's see how it works. So first of all, let's define
    variables, let's define a function, let's say define, let's say, my ad. And let's say
    it receives two arguments, let's say a and b. And then let's say C is a plus b, let's
    say that C are our c value, that's a c value or some value, whatever, whatever you want
    to call that value, some value. That's it. Let's say we did, we did that. Now we want
    to access that some value from outside the function. paint some value. By the way, let's
    first call this function, let's say my app, add four values, let's say two, three. So
    two will be copied in a three will be copied in B. So then, let's access let's try to access
    this value, some value, it will throw an error. And the reason is this variable, some value
    is not accessible outside this function. What if we want to access because this is defined
    inside the function? What if we want to access this? I mean, what if we want to compute some
    result and then use that result outside the function? So the way out, as discussed in
    the last video is return statement. Return Value. And now if we call that again, let
    me let me go if we call that again. Now, what we haven't actually registered, by the way,
    remember this, that's, that's a common error I got in that era, a lot of a lot many times.
    If you change the implementation of the function, you have to rerun that cell, you have to register
    the updated copy of the function to the Python, otherwise, you will be getting errors. Probably,
    yeah. What's the problem here? Now, when somebody Oh, we, oh, there's somebody is still not
    still not accessible. Because some value is not is not accessible it is it is a variable
    defined inside the function it is scope in, its the scope of this variable, is just the
    body of the function. So let's receive this output in a variable D. And then let's just
    print D and D is five. Great. So one more thing. Let's say we define a variable here,
    of variable outside the function, let's say that's a label name. That's a very lengthy
    name, but let's say that's the name variable. Well outside the function that saves value
    is three. And then
    then let's define another function somewhere. Let's see, let's define another function down
    somewhere, let's say define F, maybe G, and it receives nothing, but it prints this, that's
    a variable. out side the function. And that's it. That's it, that's a function. Now, when
    we call this function, this variable outside the function that is accessible inside the
    function. So so and and, and if this function, and if this variable is not defined inside
    here, and if there is this is defined somewhere else, and it is global or accessible, it will
    still be accessible. However, if we define a function with the same name, let's say variable,
    outside, outside the function, let's say five, now, this function will print five, if we
    because that's the local variable, that's the local variable in the function. Now, this
    will be accessed in this print statement. Let's see. Now the result will be five. But
    if you print the variable outside, now the value will be three, because this variable,
    this particular variable that was inside the function, it got destroyed when the function
    finishes. And this is available again. So yeah, so you need to know, by the way, it's
    a good practice whenever you want to, whenever you want to access a particular variable inside,
    it is a good practice to pass that variable as input argument to minimize the confusions
    because this can create a lot of confusions. So it's a good practice, although the feature
    is available and sometimes useful as well. But it is always recommended to pass the values
    as input arguments that whatever you want to access inside the function. Okay, so one
    more thing, this, this function g is returning nothing. For example, it is not returning
    anything, it is just printing, let's say something, let's say it is not printing anything, let's
    say, let's say this is a comment, let's say it is not printing anything. So this, and
    then we call this and that's it. So it has no return value. By the way, in Python, even
    if you even if any function, even if a function does not return anything, it still returns
    a value, which is called none, which you can see here. So in Python, a function always
    returns a value. If you write a return statement explicitly, it returns that if you do not
    write return statement, when the function body finishes, it automatically returns none.
    Let's see the type of this output. What is the type of this output? What is the type
    of this man, what kind of data type is this? Let's see. It's an n type, I mean, that's
    a type in Python. So downs are non type, output, how fancy Well, one more thing, the return
    statement is not only used to return a particular value, if you for example, in a particular
    function, let me write a function here. Let's say d f, that's the function is H. And then
    inside that function, you do something, let's say print, a, let's say then you define a
    variable, let's say a equals to three, let's say, then B equals let's say five, and then
    you add those values A and B. And then you do some other stuff, let's say plant something.
    And then you just write a return statement without any output or I mean it is not returning
    anything. You can still you can still I mean continue writing the function body more and
    more. But what happens is whenever the first return will be encountered,
    the function returns from there. So the effective body of the function is just that the function
    returns right from there. If you return a particular value for example C, you can receive
    that value outside the function. If you do not return anything, just type a return statement.
    That means exit the function right away. It works like the break statement and loop. Remember
    the break statement it It resembles to break Excitement bulletin means just exit the function
    right away, no problem. And by the way, when return is called the default return value
    that is returned is none type if the return is called without, without an argument here,
    so for example, let's run this function. Let's see. And let's call that function Ah, yeah.
    So it prints a, then it brings something and then it returns. And it returns, for example.
    It returns nothing but anon. It returns or not. And if you didn't see, for example, saying,
    then it returns
    a C, value of C, which is eight. And this time this type, the return value is no longer
    none type, it is probably an integer type. Let's see. Yeah, here. So it's indeed a type
    Make sense? Yeah. So return statement has two purposes, one, you can return a value,
    two, you can return, you can just return the control, you can just exit the function like
    the break and loops. Just Just one more thing. return statement can return multiple values.
    For example, let's say we have defined a function, let's say J. Let's say G, G, we already have
    defined, we can redefine it. But let's say our is our function. And we just have a equals
    five, b equals seven, and D equals let's say something. And then we just return them a,
    b, and A, D, and D. So return statement can return multiple values in a sequence. Now,
    if you receive those values, let's say X, Y and Z equals r, so a will be copied in a
    is a first return value, it will be returned in X, it will be copied in x, b will be copied
    in y, and D will be copied in z just as a sequence as you as you keep the sequence in
    the return statement, if you change the sequence and return statement accordingly. So whatever
    the first value here is the first value here, whatever the second value, here is the second
    value here, and so on. So let's run this and just print all these things X, Y, and Z. So
    yeah, five salmon and something. So this return statement is really powerful. I mean, it can
    return multiple, not all the languages, actually, not all the languages, they have feature to
    return multiple values. But Python does have feature to return more than one values. And
    more than one values of any type A can have different types, you can have different types,
    you can have different type, and so on. So that's about the that's about the return statement,
    as well as the variable scope. And whether you can access a variable that is outside
    the function or inside the function, and so on, and all that kind of things. In the next
    video, we will talk about what if we want to access arbitrary number of input arguments.
    I mean, we do not know how many arguments will be there inside. But no matter how many
    arguments a particular user is giving, let's say we want to write an add function. Just
    Just to give you an example, let's say you want to write an add function that says define
    add that say add to another function, add two. Let's say it receives an arbitrary number
    of arguments. D in I don't know how many and it has some implementation, then anybody who
    wants to call this add to it, if that person gives two or two arguments, then just two
    should be added. If the person gives three arguments, then three should be added. I mean,
    the person can give arbitrary number of arguments. How can we handle that because because the
    caller the this is the call, this is the call, the caller can give five arguments, six arguments,
    seven arguments. And earlier we saw in the definition, the total number of variables
    when we specify, we have to pass those many arguments for sure. If a single argument is
    missing, or a single argument is just more than the specified number of variables, we
    will be getting an error. But how can we handle the situation where we have an arbitrary or
    variable number of input arguments? How can we handle that? So to answer this, or to get,
    how can we do that? See our next video? It's coming. In the last video we were talking
    about how can we handle arbitrary number of input arguments. For example, let's let's
    say we want to write an add function. That should be a To add any number of let's say
    integer or floating point numbers that are passed in. Remember last time, we discussed
    in an earlier video, that when you are defining a function, the total number of variables
    that you are defining, you have to pause exactly those many input arguments. Otherwise, you're
    getting an error. But but this may be required some time that we want to add a universal
    kind of add function that has that has capacity to receive any number of arguments. But no
    matter how many arguments it receives, it, just add them all and return the result. Such
    a function, if available will be very, very helpful. Because sometimes we might be calling
    that function by just two arguments. Sometimes we might be adding might be calling that function
    with, let's say,
    three arguments, and sometimes more arguments or less arguments and so on. How can we have
    this kind of feature available, but the implementation is just one time implementation? Well, Python
    have a very, very easy way of handling this arbitrary or variable number of inputs. And
    the way you do that is when you receive when you are defining a function, you just write
    a star, and then just Brent let's say, one variable name, let's say arcs. And then after
    that, this arts will act like a list. And I mean, it will be having a lot of properties
    are this arts has a property, this this x like list, so all the arguments that you will
    send in will be received like, like you're receiving those in a in one list. And all
    elements, which are the arguments in the list, they are accessed by different indices, we
    will see lists in detail later on. But right now just think it is a collect all the collection,
    it is received by indices, for example, the ARDS, the very first element is indexed by
    zero, it is at the zero location. At the zero location, there is a three at first location,
    for example, the location index number one, which is actually the second look, the four
    will be copied at this and so on. Now, no matter how many arguments you pass a list,
    it will be of that size, and there is a function length le n that is handy to just check how
    many arguments are there. Now if you pass two arguments, the arcs will, the length of
    the arc will be two, if you have three, if you have passed three arguments, the length
    of the arts will be three and so on. No matter how many arguments you pass this arcs, it
    will receive all them in one by one and all the elements in that arc will be indexed by
    012, starting from zero until the length of the arcs. So see, for example, here, they
    said the sum sum equals zero, let's, let's say we want to add all these for i in range.
    And inside range, we just give the length of arcs for this example 12345, the length
    of arg is five. So I will start from zero till till four, because five is not included.
    So the very first time I will be zero, and our eggs in subscript zero is actually the
    value value of the first variable, which is three, so three is added to zero, then next
    time, I will be one and add the position one four is located. So three plus equals four,
    which means three equals three plus four, a sum equals whatever the some previous value
    of the sum plus for the next time, the value of i will be four, you know how this loop
    works, we discussed the loop and loops in detail. And as you move on, you actually explore
    all these numbers. And this variable sum actually contain the sum of all the variables. Now
    you can return the sum and that at this particular function acts like a universal guide a function
    that receives arbitrary number of arguments. How cool is that? Let's see in Jupyter Notebook
    to get more convinced how it works. So let's say we have define, let's say we have any
    function, my ad, they might add, let's say that function might add powerful, that's universal
    or universal. Universal might add universal, and it received receives star whatever the
    variable name is, that you can read, you can write the name arcs or you can write any other
    other variable limits. This is this is just this is just a name of a variable. Okay, then
    let's say we have let's say we have s equals zero, which is some, then we just apply a
    loop. I guess you know, the loops we have lengthy discussion on loops, in range, length,
    that's a built in function length arcs. Okay, then what should we do s plus equals r x
    i, which means access all the elements one by one. And this is again the same as S is
    equal to s plus r x i. Either way you write this way or that way, both ways are fine.
    Then when the loop finishes, s contains the Psalm, just return it, and you are done. Wow.
    Now, let's call this add function, my add universal. And let's call this function as
    two, four and five for these, and let's just print the result. Let's just print the result.
    Okay, the result is 11. Well, because two plus four plus five is 11. Now let's call
    this function for let's say, for for, let's say, five arguments. It works. It adds all
    these five numbers. Wow, that is great. I mean, now we can add any, we have one function,
    we need not write a function for two arguments, and then another function for three arguments,
    then another function for four arguments and so on. Depending upon the number of arguments,
    we need not to write separate functions. We have just one function working in all scenarios.
    While so, yeah. That's doable. I've done in front of you. No problem. Yeah, Python allows
    this.
    Yeah. In the next video, we are going to see how can we actually handle the same kind of
    scenario. But we want to handle the sequence of the input variables in a very controlled
    way. Remember, in some of the previous this this year, in this order of input arguments,
    remember that we receive three arguments and we pass the three arguments in a very controlled
    way. And then whatever these are, we don't care whatever the order here if we don't care,
    what if we want to fix the issue? Or we want to become more careful for input argument
    orderings. But then we also want the arbitrary number of arguments. How can we do that? Yeah,
    wait for the next video. And I will show you how can you do that? In the last video, I
    promised you that I will show you how can you achieve the ordering of the input variables,
    but still having the arbitrary number of them. Remember, this looks like much familiar to
    you, that's a call that can be made to a function. And remember, the function definition in some
    previous slide was like C one, C two, and C three maybe. And then something. What if
    we want an arbitrary number of arguments to be passed, but we want their control. For
    example, let's say this particular variable symbol name that acts as a key, that's a variable
    name, and that's the value. So let me call the variable name as a key. And let's This
    is the value that is copied in the variable. That's another key that's a value, that's
    another key that's a value and so on, what if we have a lot of key value pairs? What
    if we have a lot of them. And we also want to check which value is of what key, let's
    say we want to specify those. But we want to specify an arbitrary number of them. Let's
    say here, for example, there are only three, let's say we want to pass five of them, six
    of them, and then we want our function to perform accordingly. No matter how many input
    arguments it received. Yeah, and and maybe inside the function, we may have applied a
    check that if the key value is C one, then do this processing, if the key value is C
    two, then do that kind of processing and so on, let's say, based on different variable
    symbol names, we want to process the value differently, how can we achieve that, and
    still having the need that these number of variables can be can can be in a variable,
    variable length, they can be an arbitrary number of those. So Python gives you again,
    a very, very simple way. Rather than writing a simple single star, you write a double star,
    and then you receive in whatever variable name. And now in this double double star means
    you are receiving a key value pair list. It's a list of key value pairs. We will see that
    that resembles two that resembles to a data structure in Python called dictionary. We
    will see dictionary later on in detail but right now just just consider that this input
    argument this input variable C, it contains a, it contains a list of key values pairs,
    and then you just you can just iterate over the sea you can just apply a for loop to check
    the contents of this Remember, we have actually done that kind of thing in the, in the portion
    of loops. Yeah, here. Remember that was a key. And that was a value that was a key that
    was a value. And we did that thing, we could explore the we were able to explore the dictionary,
    just just using for loop. Yeah, it's the same thing here. It's not exactly but you can think
    of that that's exactly the same thing. So you can explore that, that see looks like
    a dictionary. Now this is key, this is value, this is key, this is value. This is key, this
    has value, you can this x points, the first key, then C of x point to the value based
    on the based on the key x, and then x point to the second key, then the second value and
    so on you that that is very simple procedure, you're just printing all the dictionary, but
    you can, you're printing all the variable names and the values, but you can do very
    complicated processing, if you want to, let's go to our friend Jupyter Notebook to just
    get convinced that this indeed works. Let's see. So let's define a function first. So
    d f, that's the function name is Brent, all
    variable, variables, and values. So that might be a function name. While that's lengthy one,
    but descriptor one, maybe we can make it more descriptive, paint all the variable, variable
    names and values, while that's more descriptive a guess. So it receives, let's say, doublestar.
    Any variable, let's say the variable name is again, let's say arcs or anything, whatever
    you want, then what we do is for x in orgs, just Brent, let's say, variable name is just
    Brent x, and then the sprint x and then just continue, and value is value is our eggs of
    x. So let's say you, you done this, you did this. So the variable name is this, and the
    value is this, okay, and you want to do this for all, all the all the variable and value
    pairs that you that you send at the call time. So now let's call this brand, all variable
    names and values. And let's call this let's say the variable first variable name, let's
    say is a, and its value is three. The second variable name is let's say B, its value is
    capital B, let's say the third Will you third variable name is C, its value is CCC. And
    let's say the fourth variable name, I mean, you can define an arbitrary number of arguments
    here. Wow, that's amazing. That's the fourth variable name is why its value is 6.7. And
    further notice, you can you can pass variable and value all have different types, I'm in
    different number of them. And and much more. Yeah, you can do that. So let's call this
    function by just having four variables and their values. Let's see what we got. So well,
    variable name is a and the value is three variable name is B, and the value is B, variable
    name is C and the values CCC, variable name is why and value is 6.7. You can give an arbitrary
    lampi list here if you want. And Python just allows you to do that. And it allows you to
    do that in a very, very simple way. That's amazing. That's amazing. I mean, that's, that's
    why a high level language or radio, a powerful language should should have a feature. So
    Python does have this feature. I'm really amazed. I'm really, really astonished by time.
    By the way, I'm not saying the other languages don't have this. several languages actually
    support this kind of feature, but Python supports it in a very easy way. It's very easy to do
    that. I mean, it's not not a rocket science. Yeah. Okay, so now we have had an arbitrary
    number of arguments even when the ordering is really controlled.
    We have one or two more videos on functions. Just to explain a bit more than we will, then
    we will practice on Jupyter Notebook, we'll practice we will play with these functions
    a lot. And we will be calling one function inside the other function and so on, we will
    be having one better program just just program and noodle Jupyter Notebook just to get comfortable
    with this functions. But before that, let's have one or two more things to discuss about
    the functions. Yeah, let's see. So I hope to see you in the next video. Okay, I really
    want to talk about these default values for a function as well, because that's important
    and mostly needed. The default value is a value of the input variable that you assign
    well, while you are defining a function, and if the value is, for example, if you call
    this F, with let's say, the input value three, then three will be copied in the sum and the
    print will be three. But if you call this function without the input, then this value
    acts as as if you have passed this. So this is the default value if you do not supply
    the value, this is the value that is going to operate. And by the way, you can have multiple
    variables with default values, some variables with default value is defined some variables.
    With default variables, a default value is not defined, and so on. So you can have this
    one here must be taken here that the default value, when you actually define the function,
    and you compile this function, actually, you you run the cell shift enter in Jupyter Notebook.
    At that very time, this variable is assigned this value at that particular time, it is
    not assigned at the call time. So sum equals to zero is already there, when you actually
    press Shift Enter for a cell that contains this code.
    Now later on, if you pass a value, that value will be overwritten on some, if you don't
    pass the value zero will go on, it looks like very easy, but one care that I want to mention
    here that I haven't mentioned earlier, in Python, there are certain variables that are
    that are referenced rather than copied, I will discuss the referencing in the copying
    data in detail in data structures. But let me just tell you 111 example, let's say you
    define a list, let's say one, two, and three. And then what you do you copy this list into
    another variable, let's say l two, what will happen is in the memory, this list in a particular
    way, this is not the exact view of the memory, I'm just showing you, let's say this is the
    particular memory layout for which this L is pointing to this L is label for that l
    two is also labeled for that, which means actually in memory, this is not the copy of
    the structure that is made, I mean this is not like in variables. For example, if a is
    equal to three and b is equal to a, a will be a will be a position in memory, and B will
    be a separate position in memory. That is what a view of the memory in ordinary variables
    are. But there are certain variables in memory just for memory efficient and cost efficiency
    and time. People have people have designed these data structures in a way that when you
    copy them, when you just assign a variable to another variable, the memory view doesn't
    change the just it's it's another name for the same for the same for the same memory
    location. So what happens is if you change any value, and let's say l two, let's say
    l two, at the very, the zeros and add the zero index, let's say you change that by minus
    nine, the because it is the same view in memory that changes minus nine. And now if you print
    the elements of L rather than l two, you will get the changed value, you will see the change
    value. And that happens. Now why that is important in terms of these default values here for
    the function. The reason is, if you are accepting a list, let's say the default is a list, and
    you're accepting a list and you are also defining some default value for the list. If that's
    your definition, let's say then this list this default value is assigned at the ad the
    very first at the very first time, and this L is really a local variable inside inside
    the inside the memory. Now when once this cell is run, not the call time at the at the
    sowhat call the compile time, when the cell is run this L is assigned this and that just
    happens once. Now if you call this list with some other list let's say l to let's say two
    three and four. Then if you call this L two, l two will go there it will be copied in L
    and everything is fine, but don't then expect this the contents of L to to stay same as
    staying l because l is this default. values, they are assigned just once. And they stay
    as it is, every time you call the function, they don't change. They are not assigned at
    the call time they are assigned at the compile time and they stay fixed. So that care must
    be taken. I will show you that example that particular example, in Jupyter Notebook shortly
    at this, this might be confusing right now, because we have not defined, we have not seen
    lists in detail. But I just want to make this point. I just want to mention this because
    that's important difference with ordinary variables that I mean default values, just,
    I mean, just like like a value. And if you don't supply a value, the default value just
    works. But with the variable that are referenced by variables, you may expect something else.
    And the Python function behaves maybe differently. And that's because these default values they
    are assigned at compile time they are not are compiled time. Actually, this is not a
    compiled language, I should not use the word compiled compiled again. And again, just think
    when we define this function, and we run the cell at that particular time, the default
    value is assigned. And the default value never changes. It stays fixed. Yeah. So and I will
    show you that example. Why don't we move to Jupyter Notebook and see that example? Yeah.
    So or why don't we do that in the next video? What do you think? This video, okay, same
    with you. Okay, let's go to Jupiter and mode notebook and see the default values. For example,
    let's see.
    Let's say we have define a function, let's say GG, and the default value s is equal to
    four, let's say that's a default value. And we want to print let's say s, if available.
    From the call time, if not available, then four will be printed. Now we print now right
    now we are going to print, now we are going to press Shift Enter at that time, S is assigned
    to for S has no value for it is assigned there. Now we call GG, let's say and we call GG without
    input arguments. Now the four will be printed. If we call this GG with some input argument,
    let's say 56. Now the 56 will be printed, no problem, everything is fine. Let's see
    about the lists. For example, let's say the list is, let's say 123, that list, and then
    l two is simply let's say l two is L, then what we do is we change the contents of L
    two, let's say we change the very first value in L two, and we place that values minus nine,
    and then we print L. Now, you might be expecting that l is a different thing, l two is a different
    thing. Because l and l two, they both are pointing to the same memory. This, the content
    through l two actually changes the memory view and l also changes and that gives the
    result minus nine in L. Well, the behavior that I want to show you is different in the
    default values. When we when we talk about for example, let's say we define a function,
    f f and it accepts a list and the default value is empty list, or the default value
    is let's say one, two, that's the default value, let's say if, if no list is passed,
    the default list is one two. Now, in this particular scenario, if we just print, so
    for example, for i in the list, brand, I let's say we just print all the list. That's it.
    Now we will press Shift Enter, and at this time this L is assigned this value, and that's
    a default value that never, that is not going to change. Now let's say we have an L tool
    that is simply let's say two, three and four, or let's say 12, three and four. And what
    we do is we call F and we just press Shift Enter. Now, why don't we call f f without
    anything. So, the default list is printed, if we call this f f with L to the L two will
    be printed. Now the notice that this L two actually is copied in this L because we supplied
    it. So l and l two you may tend to think that l is now also pointing to L to an L has also
    the same contents as l two. So if next time because because of the behavior of these lists
    because they are by Reference. Next time you make you make might be thinking that because
    l two is past there, so l two L is also L, L two is copied in L in a memory view way
    layout. So l has also the same data as l two and next time, if we call this function without
    input arguments, then l might be pointing out to L two values. So, 12 three and four
    might be printed, but that is not going to happen, the default values they never change.
    So, again, you will be getting one, two, so, the behavior of these Reference Type variables,
    that is different ordinarily, but when you do that in in the default value structure,
    that, that, that might work in a different way. And the reason is, you, you must know
    that these default values they're assigned at, at the time when the function is created,
    not at the function when the function is called. And they are not going to change whatsoever.
    So, so that was about the default value. And by the way, the default if it was a simple
    concept, I guess I have made it too complicated by telling you layers and default values and
    creation of these variables, at what time and at the call time, I made this complicated,
    I guess, I shouldn't have told you the list values and all that stuff. But but that's
    true. And in whatever I have told you is true. Maybe I have told you in a very complicated
    way, but it's true. Yeah. Okay.
    One more video on the functions and then we will be practicing functions in detail on
    on Jupyter notebooks. So just be or one more video with me. Hope to see you in the next
    video. Okay, this is probably the last video on on the functions. Yeah, we will, we will
    be having one more video. But but that will be like coding and practicing all the concepts
    that we learn about the functions not? Not something not not new theoretical concepts.
    Yeah. So let me ask you a question to actually, to actually make you understand about this
    slide. Let me go to the Jupiter and ask you about a few questions. Let's say you have,
    let's say, let's say you have this particular function, and you, let's say my ad, my ad
    universal, let's say we have written that function, maybe two or three or three videos
    before, let's say you have this function, you have written this function, and you are
    very, very excited, wow, what kind of masterpiece you have generated, it can add an arbitrary
    number of values pass in it well, but this particular function is written inside this
    particular file, which is mastering Python zero to hero. Later on, let's say two or three
    months later, you are writing some code for some, some project or you are doing something
    somewhere and you are writing code, and there you just needed.
    You just needed a, you just needed a code for adding a lot of a lot of values together.
    And then you just remember, oh, I have written some function somewhere. How can you use that
    function? One way is to just go back to that file mastering Python zero to hero, and just
    copy this function, this particular this code and paste in the new file, run that, register
    that and then call that happy. What if you want to use let's say, 100 different functions,
    let's say you have written a lot of functions in a lot of different files. And now you want
    to use all of them. And, and let's say this is a repetitive kind of demand several times
    you notice that this usually happens that this particular kind of function, you require
    almost every almost in every project, let's say a set of maybe 50, or 60 functions that
    are that are required always, one way to do that, as I told you is to jump just copy paste
    those functions in every file, run them and do that. Another way is to just just I mean,
    make a module a file of containing just those functions. And whenever any of those functions
    is required, just import that module into your coding file, which has one line of code
    and then access all the functions as if they were they were they were actually available
    in in the port file that you are working on. So that's about the that's about making modules
    of so module is basically a Python file that contains functions that you want to use in
    several different coding projects or the functions that you don't want to write in your the functions.
    Having the implementation that you don't want to write in your grant coding file, so you
    can have several of those functions stayed somewhere else in a different directory they
    are residing there, whenever you want to use any of them, you just import the whole module
    and use the functions. So, so module is just a Python file that can that can contain a
    code for you that whenever you want to use, you can use it. Normally it contains functions
    maybe more than one function and several functions. Normally, it contains functions that you repetitively
    use, and that you have written once in very careful way. And then now you want to use
    it again and again in several different ways. You need not to write the function definition,
    in every coding file you need, you just make one coding file, or that that is the most
    important for you, that is called a module where wherever you want to use any of those
    functions that are there in that module, you can call it, you can use it. So that's about
    the modules we are going to make. I'm going to show you one example of making module and
    how to use that. But but to use the module, we need to actually specify the path where
    the module actually resides using this cess module. So and then we have to do some this
    import kind of commands. And then I mean, there is some work that we need to do to actually
    get this module running in our code. So in the next video, I'm going to tell you what
    that extra work, very little amount of work what that extra work you have to do. So here,
    for example, my funks.py, that's my Python file, and it contains these two functions.
    And let's say I want to use one of these have both of these functions in some other file,
    and that file contains this particular code. So in the next video, I will show you how
    to how to actually make and use the modules. Yeah, so hope to see you in the next video.
    Okay, in the last video, I told you about modules module is just a Python file that
    can contain a code that can be used anywhere, if you want normally, that module. Normally,
    the modules, they contain a lot of functions, but they can contain variables and other values,
    and so on. So think about file myfonts.py, that contain this, these two functions, and
    think about a different file, maybe Jupiter, maybe you're working in a Jupyter Notebook.
    And now you want to use these two functions. So you first have to import another module
    call the system module says you have to have you have to make this path available. There
    are a lot of built in modules that are already there in the path all the already there in
    the search path. When you want to call a function, it is written in some module that is already
    in the search path. If you're making your modules, you have to either
    either copy those, those modules into the modules that are built in or if you want to
    maintain them separately somewhere else, then you have to add the path of these in the search
    path as well. And the way to actually insert this path is sis dot path dot append. And
    then you actually write the the path of the directory where this module file one or more
    files are located. Once this is added to the path, now you can write the import. And you
    can import your file and your file as it is or you can import your file with some other
    name if you want, you can rename that on the fly if you want. Once this is imported, now
    you can use all the functions like the built in functions, the implementation of these
    functions are not there in your coding file, you are just using those and you can now import
    this module into some other file and use their and so on. for, for, for for very large kind
    of projects. It is good to make modules. Actually it is better to make packages, which is actually
    the directory structures that contain modules. But modules at least are really good too,
    for maintaining a large amount, of course, or actually the functions that you want to
    use again and again. So let's just let's let's make a module, why not? So let's make a module.
    Let's say let's go to Jupyter Notebook. Let's create another file. Let's create another
    file, let's say new Python three and let's let's name this file as my IE let's say let's
    let's name this file as my universal, let's let's use underscores my universal functions.
    Let's classify the name. Let's create another notebook. Right now it's just a notebook that's
    defined some functions. Let's say we want to define one function as jack, all orgs.
    Let's say that's the function it receives, let's say,
    let's say it receives a dictionary like input. And then it checks the date, let's say check,
    set check type of all arcs. And let's say, let's say you write a function check, if not
    numeric, let's say, let's say you want to write a function that that just accepts a
    lot of arguments. And you want to check whether any one thought, if any one of them is not
    numeric, you want to return let's say, a flag. Otherwise, you want to return a true, let's
    say, so for example, you may you may need this function in several places. Let's say
    in in your core, you're expecting numerical inputs. And if the input is, and let's say
    there are a lot of variables that you are working on if and if any one of them is not
    numeric, you might want to check all the all the variables and their values. One way of
    doing that is just to create a list. And that's it. I mean, that's and and you may have several
    of those, I mean, you can check all of them. And maybe here, maybe here, we do not need
    the dictionary kind of argument. So maybe we just are happy with just one. So let's
    say for so the output, let's say output is let's say, R or the return value that value.
    Let's say that is already true. And we will say okay, for x in ARDS, let's say for x in
    arcs. If x if is in stance, x is and float, if that is true, then we are happy. But if
    that is not true, if that is not true, then there is a trouble, then we say okay, if this
    is not true for any value, then we just return. False. Okay, we just return false. I mean,
    we need not to break anything, we just return false return means return, whatever. Otherwise,
    if we finish this loop, if the loop finishes successfully, and there is no return statement
    that is called already, then we return, maybe true, we need to do not need Actually, this
    variable. Let's see. So this function will return true if all the variables are either
    int or float. If any of them is not of this type, this function returns false. Well, we
    can have another we can have another function, maybe we can write several function, the same
    cell or in different cells. Either way, define let's say another function, universal. Or
    add all values, let's add all that's in Numerix, and all numerix. And it also contains, let's
    say, arcs. And the goal of this function is just to add all the values and return the
    sum. So let's say s equals zero for x in for x in ogs, as plus equals to tax, and that's
    it, then return us, let's say these are two functions. And maybe one more the name of
    this, or some some variable, let's say you, I mean, these are two functions. Now we are
    out of the function we are writing something else. Let's say my name let's say that's a
    variable, my name this, this does not this my name variable does not belong to any of
    these functions. And my name is Python. Course let's say that's my. So that's it. That's
    file with name my universal functions. So what we do is we download this file as a.pi
    file.pi file. So what we do really is the Go to File, let me just zoom this out so that
    you can see the download options. We go to File Menu, we download this, as we download
    this as
    we download this as well as by file, so Python file. So let's download this, or we can write
    this Python file as in some other editor if we want. So open folder, there is a Python
    file here, copy it. Now copy that file. And now you're free to go to any, for example,
    any, any folder if you want, just, for example, you go to somewhere in your directory, and
    make a new directory, maybe, maybe you want to make another directory. For example, go
    and make a directory, maybe in D, let's say, or maybe an E, let's say or maybe in C somewhere
    and then make a module anywhere. For example, in C, make a new folder, call that folder
    as my, or any name, whatever name you want, for example, my module or let's say utils,
    for example, utilities or whatever name, I mean, let's let's call it as, let's call it
    as ABC, for example, ABC, whatever. And you just made that and just copy that Python file
    here, my universal functions.by. Now, if you go back, if you go back to your there, there
    is a Jupiter, here is a Jupiter. Now you go back to your code, this is your file, go back
    to your code, let's say this file is no longer here. And what you do is you import Sis, that's
    a system module and says dot path dot bend. Right the path here where the module is located.
    So the module right now is located at ABC, this is the part of the module. Once done,
    you can import what what was the name of the module, you need to know that that was my
    my word. So I just I just don't remember the name, let's import my universal functions.
    How it appears, actually, when I when I have Eric this part, then this import command and
    after the dab completion, just fetches that file. So that that that name might be very
    lengthy. So you can rename that as let's say, my apps or whatever name you want. So you
    import that once you have imported that. Now you can use the functions if you want, for
    example, you can check the implementation of my efs.if, you see dot add Numerix, you
    want to check the implementation of that. Here, this remember this file is no longer
    in this particular file is located somewhere else. And you can call this function like
    like the built in functions, my apps dot add all numerix. And you can have for example,
    let's say accepts the input arguments, let's say 234. All that says six. And that's it.
    That's the, that's the return value, you can you can save the return value in some other
    variable, let's see. And then later on, you can print this see our do some stuff with
    this. See, that's one thing. Another way of importing the same thing is let's say you
    don't want to use all the functions, you just need this add all the metrics, let's say that's
    that's the only function that you want to use again and again. So you need not the other
    functions, let's say for this particular file, you do not need the other functions, then
    what you can do is you can just say okay, from my universal functions, import,
    add all Numerix and you can rename it rename this function as something and you can call
    that function the same way. So you do that now. You need Not to write any dot kind of
    thing, you just call add all Numerix because it is important now, and you say, Okay 234567
    and you'll save that in let's a D, and then you print the if you want, or do whatever
    with that. That's it are you can import several multiple functions or you can import all of
    them. Other than modules, there are I mean, for complex codes, I mean, this is not one
    module that is there, I mean, there are several modules. And the several modules may be arranged
    in in a directory structure, where the directory and the sub directory and the sub directory
    and so on. So the modules that are arranged in directory structure, although they are
    accessed, much like the same way, that directory structure is sometimes called package. And
    these are basically the packages that are that are most useful. And we will be seeing
    some data science packages, like NumPy is a data science package. Then, we will be seeing
    pandas, that's a data science package, we will be seeing matplotlib that's a data science
    package for plotting and visualizations and stuff. So packages, just the modules that
    are arranged in directory structures. So now you know what module is. And the old one,
    Venus two, we actually missed to import the name of have to see the name Vivi have saved
    a name there as well. So let's go back. And let's go back and do that and see how, how
    many things are available. Let's go to some other cell and empty cell. So my apps dot
    tab completion, my name is available. Remember, there was a variable. Yeah, that's available.
    So the name is Python course. So this module file does not require to only contain functions,
    it can contain any information, any data that you want to use in other files, other coding
    and stuff, and so on. So, yeah, that's about modules. In the in the next video, we will
    practice about these functions a little bit, we will be seeing how to call a function inside
    another function, how to make a lot of functions that are calling each other and so on. So
    we will be practicing more on about these functions, not theoretically, just in Jupyter
    Notebook, just to get a better look and feel of of functions more. And after that practice,
    we will be then jumping towards data structure starting from strings. So hope to see you
    in the next video. Okay, before moving on, let's just practice some, some some, I mean,
    let's get a good grip on functions and multiple functions and handling those. And the best
    way to do that is to solve actually a problem. Remember, we solved a problem when we when
    we, when we are done when we were done with if conditions, then we solved another problem
    when we were done with loops just to get a good grip on loops. Let's solve a problem.
    Let's just solve a problem using using the functions just to get a good idea of functions.
    What kind of problems should be solved here? Should we solve an older problem? Last time
    we solve a problem using loops that are sorting a list? What Why don't we? Why don't we solve
    the same problem, but in a different way? So let's go to Jupiter and see. See our file
    Jupiter file? We have actually solved a function, which somewhere using loops, just let me just
    find that out. Oh yeah, they're here. So here. So given a list of numbers, let's this make
    another list or maybe the same list that contains all the items in the sorted order, from minimum
    to maximum, your result will be another list like this. And we solve that using loops.
    Okay, let's solve the same problem. Exactly the same problems that solve the same problem
    using a different way using a different user using functions just to get a grip on functions.
    So let's say that's our problem we want to solve. So that's the problem again, and we
    want to solve that. So how can we solve that? To solve that, let's first define a function.
    Let's just make a function.
    Let's just make a function that let's just make a function, let's say define, find minimum
    and the function accepts a list. And we're times the minimum value in the list not only
    the minimum value of the list, but also the position of that minimum value. So find minimum
    as well as find out Some minimum as well as the position of the minimum in the list. So
    how can we how can we solve that problem? That's that's one standalone function, no
    matter what list you pass in, it will find the minimum. Okay? As long as the the minimum
    is defined for the items of the list, for example, the list items, or let's say all
    the metrics, okay, how can we how can we do that? Let's see, minimum value is the list.
    Zero, that's let's say, the minimum value. And right now the index at the minimum value
    is, let's say, is zero. Okay? like we did in the loops, like is, it is kind of the same
    goal, but let's try it a function for it. Okay. So that's the function fine, man. So
    how can we how can we proceed? What should we write here? Let's see a counter. Let's
    see. Concrete let's or it may be that city counter right now is zero for x in L. K, if
    x is smaller than our minimum value, if that's true, then the minimum value indeed is x.
    And the index where we found that is high, okay, great. Else do nothing I mean, else
    just go away. And I plus equals one. So move on. So AI is just the position so AI is moving
    on and on and on. As you follow the list, and M contains the minimum value and Id X
    variable contains the position of the minimum value. So that's the function for for readability,
    we might be adding an else clause just write balls. And that means the if condition finishes,
    I'm in do if this condition holds true, do that stuff, otherwise do nothing. That's just
    because of readability. If you want, even if you don't write the else clause and pass
    statement, even then everything is fine. So let's call this function just to test whether
    this function is working properly or not. So let's just find, oh, we haven't returned
    anything. We need, we need the minimum value as well as the index. So return a minimum
    value as well as the position so return that. Okay. Oh, but we do view returning that inside
    the loop that becomes in the body of the loop. Oh, no, no, no, no, no, that's bad. Because
    even in the first iteration, the return will be called an even in the first iteration,
    the function will finish indentation, remember, indentation. Now that's better. Now this is
    no longer inside the body of the loop. Great. That was a bug. We fixed it, right? Okay.
    So let's go find, let's receive a B, so a will contain the minimum value, and we will
    contain the index of the minimum value. So fine men, for example. And the list let's
    let's give it the list. 13423409. Let's say now the minimum value is zero. And that minimum
    value appears that 0123. That's the third index. So b should be three a should be zero.
    So let's see, what's the value? What's the result? So Brent? A, B? So A is zero? Yes.
    And the position of minimum is three, I guess it is working fine. rate. So that's one function,
    find a minimum? Let's find another let's write another function. Swap. So define. define
    another function, let's say swap values. And what we do is it it actually accepts two indices
    index one that actually accepts list then two indices, index one and index two. And
    what it does is it actually swaps the value of index. So index, one value should go to
    index two position and index two value should go to index one position in the same list,
    and then it returns the list. Okay, great. So it would it so so that's, that's a good
    example it would, it accepts a list type variable, it accepts index type variable which are integers.
    Great. So
    let's continue with let's define a variable temp that contains l ID x index one, just
    store it in a temporary variable, then at this particular index, next one, just copy
    this value. Don't worry, we'll see lists in detail. Later on now list. Now at index one,
    the value of index two is copied. But it is not overwritten, because we already have saved
    the value somewhere before that copying appears. So l at ID x two is simply damp. And now return
    the list. So that's how you can swap the two values if you want. Great. So let's just check
    it, whether the two values are swept or not. So let's say list is 236. And seven, that's
    a that's list. And let's say we want alto that is swept values. And let's say we pass
    the list and we want the values to be swept at position one, and position three, which
    may add position one, the value is three, because the position starts from zero, and
    at the third position, the value is seven. So we want these to swap. So the result will
    be 276. And three, let's see what's the result? So let's print out two. And yeah, it works
    great. What else? What else do we need? So we have find a minimum function, we have swept
    values function. What else? So yeah, what should we do? Now let's write the main function
    sorting. Let's write that function. And we will call we will use these kinds of functions
    inside that function when you call these functions. So let's define sort list. Let's say that's
    our function, it accepts a list and it returns a sorted list. Okay, what should we do? What
    do you think? What should we do for the very first time? Well, first of all, we should
    check whether all these list it contains the list contains all the numeric values are not
    let's say we're just doing this for numeric values. So, we should first check the all
    the arguments are are of numeric type or not, for that, we should write a function that
    should do that oh, remember that function is all written in in a module remember that
    module we made that module ourselves? So, we can import that module if we want import?
    My remember that my universal functions and we just need that function we just need that
    function one just from from my universal functions import what import check if Numerix check
    if not numeric, as you can write that function name something else, but justice. So you import
    that function. Now you may be able to use that function. So after that, you can use
    that function. If check, if not, numeric list or remember that function returns true if
    all the values are numeric, otherwise, it returns false. So if it is true, then move
    on the if it is not true. If it is not true, what should you do? If it is not true? If
    it is not true, then you might be printing an error. Error. Last does not contain numeric
    values, maybe that and then you just return. Return. That's it. I mean, return. Don't need
    to write anything in return. Fine. Great. So else we need not to write else because
    this return will take care of that but it is for readability. That's good, right health.
    If all are numeric, then what should we do? Okay, what should we do? If all are numeric,
    what we do is we will be doing what we will be fine minimum. We'll be finding out the
    minimum and then we will be swapping the minimum from
    what should we do what we we have already a function find a minimum that we can call
    just right away we have a function swap values that we can call right away. We already have
    used this function. How can we combine all these functions? How can we use all these
    functions just to achieve the problem sorting, we want disorder list. How can you do that?
    Okay. Yeah, that's, that's, it looks like it looks like a different thing. Maybe? Maybe.
    So, let's just write out, let's just for x in the list, let's start thinking here for
    every element that is in list for x and list what should we do? We should we should find
    out the minimum and slap the minimum with x r. So, we should find out the minimum as
    well as the index of the minimum and should slap it with with the value x and everything
    will become great. Yeah, I guess Yes. Okay. So, what what we are going to do is we are
    going to maintain a counter right now, the counter is zero, which is just the index,
    which we are going to do is we are going to find out the minimum minimum and index where
    the minimum lies. So, by find minimum in the list, so, it will return us the minimum as
    well as the index where the minimum lies and then what we do is, we will say, Okay, okay,
    what we want to do is, L is actually L is swap, swap values with index see swap values
    and list with index c. So, index c should be swapped with ID x and C plus equals one,
    will that work with that work? So, after this will the will the whole list be sorted. So,
    let's return the list is that true, I mean, we are finding out the minimum value one by
    one, the only catch is the list is updated here. And, oh, there was a problem. When we
    are finding out, when we are finding out the minimum, we are finding out the minimum from
    the list. And every time the same minimum will be returned. That's a big problem. So,
    looks like this fine minimum function is not doing our job, what we need to do really is
    the, we should go to find min function and give it that start your stock your final minimum
    from a particular index. So, don't don't search the whole list to find the minimum, start
    finding out the minimum from the following index, for example. So let's give a start
    index and maybe an end index. But let's give a starting next. So start searching the minimum
    from right from there. How can we change all the code right now? Oh, that's bad thing.
    Let's change the code. Let's say that's the start index. Start index. That's it. This
    the index right now is start index and I is also start up VB we may use a range function
    here, that might be much more feasible to us. So let's use a range function. Rather
    than this let's change the coding a whole lot. That's a bad thing we need to change
    the code for i in range
    starting from start index, starting starting from start index, ending at length of the
    list and doing a step of one Okay. Now x really is x is really list at the index i okay if
    x is smaller than m then this is that an index is AI. Otherwise this we need not to do this
    because this is this is happening automatically. And rest of the story is same, I guess Yes.
    That will work out. Okay, great. Oh, there is a problem. Oh, we just missed this column
    here. Great. We fix it. Okay. Now, so if value is there, maybe this works. Maybe Doesn't
    maybe there is a bug. Let's see, let's let's just call this function. So let's call this
    function l two is sort list. And let's pass the list as to 153. Minus 870. Let's see.
    That's boss this list and see what it returns. If it returns fine, we might be happy. Otherwise,
    we will see where is the bug? If there is a bug, oh, this does not contain numeric values.
    Why not? list does not contain numeric values. Why is that happening? bliss actually contains
    all the American values. We read the problem, check if not numeric, let's see the let's
    see the implementation of check if not numeric. Let's see that. Check. If not numeric, let's
    see the implementation. And there is the bug. Because all these are numeric. So check if
    not numeric x in arcs, if not is instance then return false. So if everything is int
    or float, so if x is int or float, then return otherwise return true. So it returns true
    if all our if all our numerix. So it returns true if all our Numerix so not true means
    false. And why why does Why does returning for us? So that is just was let us just see
    why it is returning false. That's that's the bad news that something is happening wrong.
    Let us just see how this is working. So that is just check. Check, if not numeric. And
    let's pass the list this list. And let's see what is returned. Let's just print the return
    thing. But it is either true or false. So it returns a false why it is returning a false.
    It is a bad thing. Why does they're turning a false? Let's go to the File. Let's go to
    the File. Here. Sorry. Let's go to the File. Here in this directory. Let's open up this.
    Maybe open this in simply an old bad. Maybe an old bad, why not? Or maybe some other fancy
    editor. Let's open this up and see what is happening. ad format font, let's have a bigger
    follow on and see what is happening.
    Self face one of 20 bugs are bad, they're really bad for x and ogs. Okay? If not is
    in stance. So first of all is in stance this, it will return true always okay. If not true,
    which means false. Then we'll move on and the loop will be running if anywhere you where
    it is finding out where it is finding out basically. So this this is working really
    fine. Let's, let's let's write this function somewhere inside our notebook and see what
    is let's say rather than this. Let's say this function like check the metric to check numeric
    to check it not numeric to let's call that function and see what happens check numeric
    to it is returning false again. Why does returning false? That's amazing. Where is the false?
    So two is integer? Yes. One is integer. Yes. So true. True. True. True. All these are true.
    OH minus eight might be a problem. minus eight might be a problem. Let's see. Maybe. I don't
    know. Well, well, there is still false. I mean, I'm stuck here. Guys. I'm stuck here.
    I don't know what to do. I don't know what to do. I have to debug this function, I have
    to go inside that function and see what is happening. So what we really are eggs. Oh
    my god, the big trouble big trouble. Yeah, I found the air. We are passing a list. And
    that list is just one argument. That is not a lot of arguments we have to pass all these
    arguments in in a different way. I mean, if you want to, you're getting you're getting
    the bug, the bug is we're passing one variable, not a lot of them 2153 817 these are not all
    different variables. For example, if we just go inside and print x, for just first x, it
    is the all it is all the it is all the list. It is all the list. It is not the variables
    one by one. Let's see. Yeah, I found the bug. Found the bug. Wait. Yeah, see, it is not?
    It is not a lot of it is not a lot of variables. It is not a lot of arguments. It is just one
    argument that is in the form of placed variable. That's incredible. What should we do? Should
    we go inside and add another function check if not Americ for lists, rather than variable
    number of arguments. What should we do? Let's write another function that check for the
    list. Let's write here check numeric to it contains the list for exam just accepts list
    ello or maybe l or whatever x or art just simply, you can call the or l list. And it
    goes through all the list. And does does the same job as previous. So now this will work.
    So the function that was there in our module is no longer working, and it will not work.
    So we are not going to use the function that is in the module, we are going to write another
    function that will help us here. And we have written that, and here we go. It just chained
    that function to that. And we just we just throw that out again. And let's see what happens
    now. Oh, there was another error whichever. Find a man missing one o v v did not find
    this fireman is missing the starting index. So the starting index is C rate.
    Right? That's a problem. That's a huge problem. Let's just sorted Oh, my god list finally
    is sorted. Oh, huge, huge, huge. So you see, you can call the functions inside other functions,
    you can call the functions from modules. If they are no longer working or no longer beneficial
    for you, you can write new functions, you can call them you can. Yeah, all that stuff.
    I guess that that lengthy video taught you a lot of lessons, how to how to code actually.
    And this actually happens when you are doing tasks that are really big. You have to define
    different functions, you need to define different functions for modular approach, and focus
    on each function as a separate entity. And that that makes much simplicity in managing
    the code and bug fixing and all that stuff. You see, I fixed the bug by just noticing
    that just by just focusing on this function. I have not thought anything else, just focus
    on that function go and see the implementation fix that everything else stays the same. Yeah,
    so too lengthy a swap here. Okay, now you have done a lot of practice about functions,
    loops, and a lot of stuff. That was all the basic programming in Python. In the in the
    next video, from the next video, we will see the real power, a much more real power of
    Python where you need not write a lot of loops and a lot of gold and still you will be able
    to achieve a lot of stuff. And for that we need to go through the data structures that
    are available in Python. So from the very next video, we will start seeing strengths
    that study or structure we will see less in detail we will see set in detail we will see
    dictionary in detail we will see tuples in detail. And after going through all these
    data structures and getting a good grip for the data structures. Then finally we will
    move we will move to the packages that are available for data science, particularly NumPy,
    pandas matplotlib. And we will see maybe I include maybe I include one or two videos
    for psychic learn as well. So hope to see you For the whole new phase in Python, the
    data structures, so we'll hope to see in the next video. Okay, let's dive into the long
    awaited strings. string is basically just a sequence of characters. And it's a data
    type, it's kind of a data type. In Python, it's much more powerful. The reason, the reason
    of, I mean, making this a whole new data type in, in almost every language is, the reason
    is that almost all the data all the text that appears in sequence of characters, so making
    that sequence of corrector, the whole text as one kind of data type, and writing special
    kind of functions to, to deal with that text might be necessary. And that's what the string
    is. In Python, for example, you can declare a string variable s, or any variable name,
    by just double quotes, let's say ABC, are our equal monthly by a single quotes, either
    way is fine, d f. So either way is fine, you can declare using double quotes, or single
    quotes, either way is fine. One thing is, be careful, don't mix. I mean, don't start
    by a single quote, and think that now I will end with double quote, and that will be fine.
    So don't mix them together. If you're using single quotes, use single quotes, if you're
    using double quotes, use double quotes, don't mix them together, that might be much more
    confusing later on. So let's say this S is a string, Python is the best language for
    data science. That's a D is another string that is defined by single quotes. In this
    course, we are going to learn Python, then you can print s, different in a different
    way, let's say you will call you can call a brand s, you can call a print to D. Or you
    can just by the way, you can you can add two string variables s and D. And the result is
    a new variable. That's how the plus symbol works in strings is plus in strings means
    just concatenate concatenate them together. So first, you just copy this string, the whole
    string, and then you just concatenate the other string with it. And the result is a
    new string. Now that's a new variable, you can use that variable and do a lot of stuff
    with it. So let's go to Python and see actually, the brains in in the strings in in the running
    form. So let's say S is
    string, let's say, right on is good language, let's say. And let's have another string T,
    that is using single quotes. It's good for data science, sci fi. Okay, it's good for
    data science, let's run these two, and see the type of s was the type of s. The type
    is str string, str, that's what the type is. And if you just print s, that will be printed.
    Python is a good language. Remember, so far, we are using this sprint. And always we use
    this kind of Hello or something like that. That basically is a string because by the
    way, the sprint function, actually, it takes an arbitrary number of arguments, we can print
    hello, then we can print anything in another type, then we can print another Hello, let's
    say hello to hello to that's a multi multi variable argument function print, then we
    can have another string maybe Who are you. And then maybe a floating point number 5.9.
    So we we have used these kind of, we have used these kind of, I mean stuff a lot. We
    have used print function. And we were using these double quotes again and again. But but
    these are actually strings that we will be that we were using later there. So the spring
    function actually accept strings and all these kind of Normally, the whenever you use print,
    normally you're using it normally you're going to actually display some text, and maybe you're
    writing that text into some file and so on. So this string is highly, highly useful. Most
    of the data is available in the text form in the screen form. And we want to process
    the data we want to find the anomalies in data, we want to fix them again, we want to
    stay in the text. So it is good to have a data type that actually have a lot of functionality
    that handles all that stuff. So Let's see, for example, another another, let's see how
    can we concatenate the two strings, for example, SMT. Let's say we have B, that is s plus T,
    that's concatenated. B. And that's francqui. And we is going to get an ad. While bicon
    is a good language. It's good for data science. Well, it is concatenated. But there is no
    space between two because wherever the first string ends, the second string starts right
    from there. What if we can get in a three strings? s plus another string that just contains
    a space corrector? Then this string? Why do we whatever that is there in double quotes,
    or single quotes, whatever, one corrector to track character, all these things are called
    strings. So now we are concatenated, three strings together as a space, one space string
    that contains just a space greater than T. And let's see what happens now. So Python
    is a good language space, it's good for data science and so on. Well, so
    yeah, so that's basically the introduction of string. What if we want for example, to
    concatenate? What if we want, we have a variable A, which is 12. And let's say we have variable
    b, which is the price of this book, let's say the price of this book, and a is 12. So
    let's say this is our price. Now price is in integer form S is in book form, let's say
    we want to make another string we, that contains the following kind of thing, the price of
    this book is and then whatever the private price is, that should be there. So what how
    can we do that? So let's say s, plus, maybe, maybe another string is then maybe a space.
    So that after that the price appears? Now, if we right plus and right price, price is
    no longer a string, it is an integer, and an integer cannot be concatenated the string
    in a straightforward way, like plus, how can we how can we make a message like the the
    price of this book is, whatever the value of the price is, one way to do that is to
    convert the variable price, the Convert the type of the variable of price, from integer
    to string, that means whatever the value, in this case, 12 is written, that becomes
    a string of characters one and two. And now it can be concatenated with with the rest
    of the string, and we will contain the message that we want. For example, if we now see what
    is free, that is, the price of this book is this book is 12. Oh, we don't have a space
    before. So let's let's type a space, their space is also a corrector can be handled in
    strength, while so that's how we can convert different types to string. We can have a float
    type, we can convert that to string, and so on. Another way of doing the same or achieving
    the same kind of stuff is to write Brent, the price of this book is I mean, we can use
    the power of the variable number of arguments of then price, that's exactly the same thing.
    The price of this book is 12, the price of this book, however, consider one thing, the
    print function automatically adds the space for different kinds of arguments. You can
    see that here, yeah, you need not to specify a specifier space, the space is automatically
    added if it is if it is considered to be a different argument in the print function.
    Okay, great. So that's the introduction of a string. We are going to explore string much
    in in much more detail in the upcoming video, so stay with us, we are going to see a string
    in much more detail. Okay, hope to see you in the next video. A string might be very
    lengthy, or may span I'm in very lengthy and may span more than one lines. Or maybe the
    formatting is in a way that you want to even if even if it is not very lengthy, you will
    still want the different chunks of the same string to be appear in different lines. So
    there is a way to declare multi line strength again using either three single quotes or
    three double quotes. And then three double quotes or single quotes. Whatever convention
    you follow Then you write all the string in, no matter how many lines you want, and that
    one variable actually contains a multi line string. If you now print, for example, if
    you call the print function on this multi line, that that's By the way, a variable name,
    multi line string that contains this data, multi line, multi, multi line that now the
    spelling our Spelling's around here, I just created multi line anyways, if you if you
    call that print function, this will the print will display the string as it is like it is
    there. So let's see the and by the way that the same multi line string kind of fashioned
    remember that that is used for comments as well. If you have comments that span on multiple
    lines, you can use this. So this multi line string really is if it is not saved in a variable
    and used as it is somewhere in the code, then that acts as a multi line comment. Great.
    So let's practice the multi line string in in Jupyter. notebook. Let's see. So let's
    say we have a variable A that is multi line string. And let's say the spring is this is
    line one.
    Then we have this is line two, and then we have this is last line. And this line is three.
    That's it. Okay, great. That's a multi line string. Let's see. How can it Brent a, what
    happens? So this is line one, this is line two, this is last line and this line is three?
    Why this? The first this is shifted one corrector, right? Oh, there is a space here. Let's remove
    that space if not required. And run this again. While because space is a corrector that will
    be printed if you want. Okay, what if you really want really want the following kind
    of stuff, you have, let's say brand. So what you really do is you want to bring the following
    the following options are available. And the options are, let's say dab, dab, dab, let's
    see a hyphen, a. And that does play from a that does nothing. And then we have let's
    say hyphen B and they're also also does nothing. Let's say you want our message to be painted
    in in such a way, what will happen? Let's see. Okay, the following options are available
    hyphenate has nothing hyphen B I mean, all this is a string multi line string, these
    crackers that you think they are not there, these are spaces and they are I mean the spaces
    are painted here, the spaces are painted here, we are saying nothing is printed, these are
    the spaces that are printed there. So sometimes this multi line string, it helps to format
    our message in a way that we like. So that's how helpful in most of the cases further if
    you write this multi line, by the way, if you write this multi line, comment in the
    start and end of any good script. That means the if you write this multi line way of defining
    the strings at the start and end of any good script, that code script is commented that
    we have seen several times earlier as well. So, for example, in problem solving, remember
    that we define all? Oh yeah. So that's the comment. That's a comment. Even if some code
    is written inside that will not be executed. Right. Okay, so that's about the multi line
    string. In the next video we will see because because the string really is, is basically
    a collection of all these characters. What if we want to access a particular character?
    For example, this is the first graduate is d here, the second Gregory is at the third
    correct? Is it the fourth record is S, the fifth Gregory space and all? What if we want
    to access particular characters inside the string? Because the string contains a lot
    of directors? What if we want to play with some of the directors inside the string? How
    can we access different directors for example, if we want to access seventh director of the
    string, how can we do that? So, let's see in the next video, how can we index different
    characters inside a string, I hope to see you in the next video. Okay, in this video,
    we are going to actually access different characters inside the string, sometimes called
    indexing, the term slicing is basically more relevant to arrays, lists are actually the
    immutable structures, but we will see,
    I'm just comparing, because you may listen this term slicing again and again, but really
    this indexing but we will see the indexing or slicing sometimes is you these two terms
    are used interchangeably, we will see the examples of slicing in detail in lists. And,
    and in more detail in NumPy arrays. But here, you just think that indexing and slicing are
    the same things. index. So for example, I have this a let's say this is a array, and
    I want to access its fourth element here, the fourth corrector element is E. By the
    way, this a is a variable, if I want to access the very first corrector the the indexing
    the number, the positioning starts from the integer zero, that's the first corrector.
    So if I want to print out of it, that will print g if I access for example, if I write
    the index three, what do we mean that means the fourth element, the fourth element is
    he what will be printed, what will be printed, if I access the fourth element of the index
    for a fi access this thing or space will be printed and you will be seeing nothing because
    when a space is printed, actually, nothing colorful is printed there and you might be
    thinking Oh, nothing is printed, nothing, nothing has been accessed, actually a space
    corrector have been accessed. So yeah, a more we can we can we can actually access, we can
    actually access a substring inside a string as well. For example, we want to access for
    example, a substring starting from index three, and all the way up to index eight, but does
    not include the index eight. So it will include the corrector at index three, which is he
    correctly at index four, which is space, let me write space in this way. Director at index
    five, which is Oh, correct, read index six, next record, which is F, then a space, which
    is seven, and then the correct read eight. And so this is not included, to be accessed.
    This is included, this is inside, this is included. This is not included. So we can
    access a substring. So starting from three and ending at eight. Let's see, let's see
    an example. And you'll come back to this slide again, after after a few minutes. So let's
    say we have a spring as let's say, how are you? And who are you? That's it. So let's
    do that. So spring, okay. And what do we really want is we want to access for example, the,
    we want to access the element to access the elements, you have to write the square brackets.
    That's a standard notation. In Python. Whenever you have a collection and you want to access
    different elements, that collection might be a string that collection later on, we will
    see might be a list. Maybe a tupple dictionary may be a set. Maybe a NumPy array may be a
    panda's structure, I mean, anything that is a collection, normally it is accessed by It
    has different elements, and we want to index them. The indexing division is square brackets.
    And indexing always starts from zero rather than one. In Python. There are some languages
    in which the indexing starts from one for example, MATLAB, the indexing starts from
    one but in Python and in several other languages. The indexing starts from zero, which has some
    benefits or starting with one it has some benefits. So starting with zero is okay is
    okay. So let's say we want to access element at index five. The element at index five is
    actually the sixth element in the string starting from zero. So first, second, third, fourth,
    fifth, sixth, so our will be printed. So let's see. Our is printed. Let's check the let's
    check the type of this return value. Let's check the type of this this one element which
    is our what is the type of it subtype of different elements in a string different characters
    in a string? What are the types
    So what is the type of it. So the type is also string. So each and every corrector is
    also of string type. In some other languages, the type might be a corrector. corrector is
    another type, but in, in Python, each and every one character is also a string. More
    than one. correctness is also string, as long as they are accessed from a string. Okay,
    let's access for example, the element number three to element number, let's say eight.
    So the result is our so element number three, not three, actually starting from index three,
    which means the fourth vector, which is space, and then e, r, e, and then space, and then
    we finish. if you for example, move to from three to nine, let's say, and the the rally
    will be our why or we may move to from for example, we may start from the very beginning.
    So for example, index zero, we may end at the index 10, but not including the 10. So
    the result is, how are you and then I mean, why Oh, and not the you included, because
    that's index number 10. And index number 10. The last index is not included. Great. We
    can have negative indices in strings as well. So a negative index is just just the indexing
    from the right side, not from the left side, for example, on negative index. So minus one
    points to the last corrector. For example, you similarly minus two points to the second
    last corrector, and so on. So minus one, that's a success, you. And similarly, we have minus
    three, and that will access why, or we may have start from let's say, minus, start from
    let's say, minus eight, and go till minus three, that means go back to go back to minus
    eight index, and then move to minus three index, okay? And minus three. In this case,
    let's see what was the result are, what is that? Why are? Oh, this are, I guess this
    are? Let's check it out. So this is this, you, this is minus one minus two minus three,
    that's an X number three. So three is not included. minus three is not included. So
    it has to stop here. Okay. That's minus four minus five minus six, minus seven and minus
    eight. Oh, great. So that should be printed, it has printed. So let's say we have rather
    than minus eight, we start from minus 12, and be raised to minus three. So we're okay.
    Great. So we have negative indices as well. And by the way, this kind of fetching this
    kind of substring is sometimes called slicing, I mean, we are just fetching the slicing,
    although the term slicing is much more popular in, in in mutable data structures. What What
    is a mutable data structure? What is an immutable data structure? Well, yeah, I should tell
    you right now, you can change, you can not change any corrector in the spring. That might,
    that might look like a bad news for you. But once the spring is created, the elements in
    the strings are not changeable. So for example, let's say at position number one, you want
    to place a corrector. Let's see, that's not possible. And the reason is, the string is
    a data structure, the string is a variable type a data type that is immutable, immutable,
    are unchangeable. Once created, you cannot change its contents, they stay fixed, you
    cannot change them, you cannot alter them, you you cannot delete certain contents from
    it. I mean, once created, it stays as it is, you can copy this into another string, you
    can copy and paste, but you can get a substring and copy into another variable, for example,
    but the contents of s cannot be changed.
    So all the kinds of data types in Python that are unchangeable, the contents are not changeable.
    They're called immutable. And string is immutable. So so the the time slicing makes much more
    I mean sense or it is more popular in the data structures that are mutable, that are
    mutable, although, you can use time slicing indexing both interchangeably. But it refers
    to roughly in reference to fetching the sub structure or substring. In this case, in the
    list, it will be a sub list or so on. So that's what slicing is. Yeah. Great. Why don't we
    do some more fun with this spring?
    Yeah,
    let me show you more fun with this rank, more indexing, let's say you start at index zero,
    you go to index 12, but not including 12. And then you jump, you take a jump of two
    rather than one, what we'll do is, it will fetch all the corrector starting from index
    zero, all the way to index 12, but not including 12. But it will take a jump of two rather
    than taking the jump of two. So first greater than take a jump of two, then pick a corrector,
    then take a jump of two and then pick a corrector. So it will actually pick every other characters
    starting from zero. So let's see that. So for example, if you remember the string, that's
    the string. So it starts from h Fine, then it skips Oh, and go to W, then it skips bass
    and go to a then it skips R and go to E then a skip space and go to u and then it skips
    Oh, and go to a shoe and then the cloud achieved and we stop there. Wow. So the general way
    of slicing or indexing the general way is you have a starting next start, then you have
    an index and then you have a step size. If you do not mention the step size. the step
    size by default is one that we were doing already. If you do not mention the end, the
    default end is the building and the total list size. If you do not mention the start
    the default start is zero. For example, let me make that a comment and just practice a
    few for example. Let's start from zero we do not mention the start let's start from
    zero and go to 12 if you do not mention the starting index that starts from the very beginning
    zero go till 12 Okay great. If we do not mention For example, we start from three and we do
    not mention the end that means go till the end starting from index three including the
    last corrector Okay, if we do not mention the step for example, if you start from one
    go till 12 and we do not mention the step, the default step is one okay. There is one
    way of reversing the string, I mean very beautiful way I mean, you do not you do not start the
    mention and you do not mention the start, you do not mention the end, and then just
    take a step of minus one in this particular way. The Start and End index they are they
    are just swept and you get the string reversed way. While so that's the reverse great. Isn't
    that fancy? Yes, it is. Okay, a lot about indexing, you can find out the length of any
    string by using l m function, you can find out the length of any substring if you want
    to if you have a substring using again a lamp function, alien, that's okay. Okay, and now
    you've seen how to access sub strings and how we cannot change the elements of a string
    because it is immutable, but we can access them, we can access them, we can just display
    them, we can analyze them and so on. In the next video, we will see some functions that
    are supplied for string processing, what we can do with strings, I mean how can we manipulate
    those strings, although we cannot manipulate the contents of a string, but we may copy
    a string we may get explained, manipulate it and save it to another variable and how
    what kind of functions that are available in string in string data structure string
    data type. So let's see that in the next video. Hope to see you in the next video. Okay, let's
    see different functions that are available to play with the strings. In this dense string
    data structure, let's say you have the string a a lot of spaces, these are a lot of spaces
    at the beginning and these are a lot of spaces at the end there are some spaces in the middle
    as well. So, there is one function called strip all the functions of the string they
    are called by taking a dot A dot something These are called methods you can loosely call
    them functions, but those kind of functions that are related to some data structure and
    called with dot, they are sometimes called methods. The term method is more related to
    object oriented programming actually string is a class. So all these are the methods But
    even without knowing that it's perfectly okay, you can call it method or function that's
    perfectly okay. You can, I mean, it's okay. It's okay without knowing what a class is
    without knowing what an object oriented programming is, this a dot some function that operates
    on this a.
    One difference with method and function is when you call a function with a dot, and you
    call some function that say, a dot strip. Then inside the definition of the function,
    this a object or the a variable is available, like, like you have passed that variable as
    an input argument. That's all you need to know about the difference of matter and function,
    the rest of the story is perfectly okay. Even if you don't know that that's fine. Okay,
    eight outstrip, it operates on a which means that a is passed in this function as just
    as input argument or it is available there inside the function implementation. And then
    the script function, what it does is it removes all the spaces that are in the beginning,
    and removes all the spaces that are at the end, and returns another string that has that
    has no spaces at the beginning and no spaces at the end, and the new string is copied or
    created in a variable b, let's say whatever that we believe we can, we can have another
    name of that variable. So let's see. Let's see the running form of this script function
    in our friend Jupyter. notebook. So let's say a is a string variable. That's a lot of
    spaces abcdef, a lot of spaces and hg gilwell, whatever. And then a lot of space, and that's
    it, this is a and then we have B, let's say a dot strip. Okay, and that's sprint B. So
    b is actually everything without spaces without the starting spaces. And without ending spaces,
    it does not hurt the spaces inside. So that's the script function, sometimes processing
    the data. When we when we read the data from a file, it may have a lot of spaces at the
    beginning at the end, maybe due to formatting issues or something like so and it is this
    function is available. If we want to remove those spaces from beginning or from the end.
    Let's see more functions. Another function is lower, like the name suggests it actually
    it actually converts all the string to lowercase. For example, let's say we have a string, let's
    say, a B, A, let's say we have a string, a equals A, B, C, D, E, F, G, and some directors,
    some other directors and Q f, let's say that's a string. And now what we do is b equals a
    dot lower. What it does is it converts all the string to lowercase. For the characters
    that are already in lowercase. It doesn't hurt it. For the characters that has nothing
    to do with lower uppercase, it doesn't hurt that all the characters that are not in the
    lowercase and can be converted to lowercase, those are converted to lowercase. And this
    is available. Yeah. Great. So similarly, we have another function called upper for example,
    C is equal to a dot upper that the like the name suggests, it converts all the characters
    to uppercase. Well, let's see more functions. Oh, there is a function replace the Replace
    function. What it does is it takes a substring and replaces that substring with another substring.
    Okay, let's see. For example, let's say we here we want to be have the same a, let's
    say the a is this thing. Let's say that's a and what do we want to do is we want to
    replace the semi colons let's say with with with the semicolon, we want to replace the
    semi colons with statics. So what we can do is we can say okay, d equals a dot replace,
    replace the semi colon with with let's say steric. Or, yeah, so let's see what D is.
    So each semicolon is replaced by a steric. By the way, if you if you want to replace
    for example, a, a dark replace, if you want to replace one is there one semi colon One
    semicolon with a string. For example, the string is star star, and, and hashtag or some
    person. That means one semicolon will be replaced by this, seek with this string, and the other
    semicolon will also be replaced by this screen. And the result will be as expected, each semicolon
    will be replaced by the screen. And that's the result what it is further if you want,
    for example, if you want, for example, let's say d equals a dot replace, if you want this
    particular substring, that contains the two semi colons, if you want the two semi colons
    to be replaced by another substring, let's say two semi colons, let's say. And that is
    also possible I mean, you, you replace one substring with another one. Right? There is
    one more function called split. That what it does what what the split does is, for example,
    you have a string, for example, let's say a equals a string, let's say, ABC, then you
    have this colon, then you have d f, then you have semi colon, then you have ads g y, there's
    Dan semi colon, then you have y y 3223. That's it. That's your string. Let's say you read
    that string from some CSV file and disappears. And now what you want, you want all these
    values to be separated out that are that that are separated by the semicolon, maybe these
    are different values, ABC is a different value, then it is separated by a semicolon semicolon
    may be an indication or token that the next value started and so on. Let's say you want
    to separate them, let's say you want to just split them all of them with a particular splitter.
    And here, let's say the splitter is semi colon. So what you can do is you can have a list
    and a dot split. And in the split, you can specify the corrector that that is used for
    splitting after and before we split that. And remember, the split function actually
    returns a list of strings, where this is the first element of the list, this is the second
    element of the list, this is the third element of the list, this is the fourth element of
    the list and so on. Because once you will split, you will be having different elements
    that are split it out. So if your brand for example, l we will be having a list of different
    strengths, ABC and all that, Oh, don't worry about the single code, the single core and
    double core is the same thing. Now we can access for example, the third element or or
    maybe the second element by index one. And the second element here is D, E, F, and we
    can work more on that. Okay. Is that it? I mean? Are these the only functions that are
    available? stripped function lower a birthplace and split function? Or is that it? That's
    all the spring is about? Maybe there are more functions? How many functions are there in
    string? How can we use them? What are the what are the total number of functions? Where
    is the list? We visit documentation? Should should we follow some book? Should we go to
    some tutorial and find all the string functions and see how to use them? Well, if you want
    to do that, you can do that. But there is another smart way. Let's say a is a string
    that you know, you write a dot and then a press tab, and all the things that that are
    there in in string, they will they will appear in front of you on several things. You can
    go to this, you can go to that you can go to that and so on. So just you can check the
    documentation of a for example, if you if you press a and what it does, let's see. It's
    a string object and all that stuff. Fine. It's a string. So further what we can do.
    So let's say a.we, press A and then we press tab. Is there anything that starts from a
    Nope? Is there anything that starts from B? No. Is there anything that starts from C?
    Yes, capitalize case fold center count. These are the functions that are available that
    starts from C.
    Okay, let's focus on capitalized. Okay, what is that thing how to use it? That's press
    colon, question mark and see what this is and what it does. Okay, so here is the documentation
    here is a doc string returns capital. I used to worry enough the string capitalized version
    of the string. Is that the same as upper? Maybe? So let's see. Now we know what it does.
    Let's just check it out, print a capitalized and see what's the result? Oh, it's got Oh
    no, it does not get delays the whole screen, does it? Did they the screen a was it does
    not capitalize the whole string? What What is a? Let's see what is a? A is the following
    string is the following string, so it does not capitalize the whole string. Oh, the difference
    between the capitalized maybe? And the upper? Is that the capitalize when it encounters
    when it encounters? No, no, no capitalized just capitalizes the first corrector. Let
    me let me read the doc string, again, returns a capitalized version of the string, more
    specifically make the first corrector have uppercase and the rest lowercase. Okay, that
    means if we have a string that has a mix of values, the capitalized will do the following.
    It will convert the first character to uppercase and all the rest of the characters the lowercase.
    Wow, that's awesome function. For example, if you have string, abs D, A, B and GG, kill
    that say. And then we call capitalize, capitalize, let's say. So what that does is it actually
    capitalizes the first director and all the rest of the directors there as it is. And
    there are other functions as well, a dot A dot, let's see count, what it does a dot count
    what it does not count. What is that thing? Let's check it out. Or maybe we can check
    that out using help. What is zero count? So let's see what is a load count. It's a built
    in function called matters is an instance of and it returns a number of non overlapping
    occurrences of a substring. Sub in Oh my God, if you I mean, that's what it what what is
    written there, non overlapping apprentice of a substring. Great Oh my god. So basically,
    there are there are a whole lot of functions of strings that are available, there are several
    use of the string, there are several ways of molding and playing with the strings, some
    of the functions that are available, some you can make your own, you can make your own
    modules on top of that, to customize your written to customize according to your requirements.
    A lot of these are available, and you should know how to use them. And first thing if you
    want to do something with strings, or with any data type in Python, first check whether
    some method is available or not. And one way to go that is just right away from here. And
    other ways to go to internet and see I want to do this in Python. with strings, whether
    there is a function available or not the good chances are there will be a built in function
    that is available. And in that case, I will encourage to use that function rather than
    to write your own one because using the built in function, or the method that is tied up
    there will be much more faster probably than the function you will be writing at your end
    even if you're too smart in algorithms. So yeah,
    so that's about the spring matters, there are so many other methods that are available.
    In the next video, we will see some more some more manipulation and processing and some
    more working with strings. And then we will move to other data structures. Okay, hope
    to see you in the next video. In the last video, we saw some methods of string. And
    these are just a few of them, a lot of them are available. We just we just discussed some
    of them. In this video we are going to talk more about strings in a particular way. For
    example, what if you want to find out whether a particular substring is there in a string
    or not. Let's say you have a string and you want to know whether a particular substring
    is there inside a string or not? Well, you can easily find out that using the end keyword.
    And similarly not in means the reverse of that, or the complement of that or not of
    that. And in keyword always will return either true or Boolean or false. If it is inside
    the screen, it will return true if it is not inside it will return false. So let's check
    this the implementation of that in, in, in Jupyter Notebook. So let's see. So let's say
    we have a string ABC ABC. And we want to check whether this string is there in this particular
    string or not. So the return value is false because ABC as a substring is no longer there.
    A is there. For example, here, a B is here, but ABC is no longer there. Yeah, so if we,
    for example, have an ABC somewhere, at least once, then the result will be true. In the
    last, in the last video, or maybe in the very first video for strengths, I showed you that
    you can use plus with strings, can you compare two strings using less than or equal to? I
    mean, how to compare two strings, whether they are same or not, for example, ABC, that's
    a that's a string ABC, I want to check whether that string is the same as ABC or not, what
    will be the result? So so so the question is, is this double equal to is used can be
    used for comparing two strings? Well, the answer is yes. Or what will be the meaning
    of less than a string as less than the other? Is that true? For example, ABC, is less than,
    let's say d f. Is that true? If it is true, for example, what does it really mean? How
    can we define one string is I mean, this string is less so than the other string, maybe this,
    maybe this operator is working based on the length of the strings. But if even if that,
    then this length is the same as this length. And to be more precise, we can change that
    length, for example, by just saying, okay, ABC, D, F, G, H, I, and I guess this string
    will be still smaller than the right string. So how this comparison is working? Well, I
    guess the comparison is working based on the based on the alphabetic order, and you know,
    the alphabetic order, a B comes first and B and C and all the alphabetic order that
    is there in English dictionaries. That's how the strings are working here. And the alphabetic
    orders for all the special characters will also be defined in Python, for example, that's
    a special graduate, for example, maybe this string is this string smaller than the following
    string. Yeah, we've done for false, because there is particular ordering. In, in Python
    that is defined for these characters that this becomes first and there's like, a becomes
    first and B, B becomes first and C and so on. So whatever the alphabetic order is, based
    on that, or you can compare the two strings, no problem. So these are also available. And
    the third thing is in function that is also available to check whether a particular string
    is inside a substring is inside or not to in another string. One more thing that I want
    to talk about in that, for example, what if your goal is to print the following, let's
    say let's say you want to print the following, we are learning. And let's say you want to
    print the string in double quotes. We are learning string here. Let's say you want to
    print this, you want this string to appear in double quote, how can you do that in Python?
    Well, it looks like same. What's the difficulty? Let's Let's call the print function. And then
    just like here, we are learning. Then write the double quote here, scraping. And here.
    That's it. But there is a problem. The reason is, the reason is when we call this, when
    we write this double code, actually, the string ends here, exactly the string ends here. And
    when we write this single code, and this double code, another string starts here. And this
    is no longer a string. I mean, what it has no data type inside. Well, how can we then
    insert these double quotes inside? Well, there are several ways. One way is to use escape
    sequence and escape sequences just like it is you use a slash and then whatever you use
    is considered as a corrector. Inside the string that is you're using it now if you want another
    double quote, you use a user corrector which is the backslash or maybe a forward slash
    and if you use that That means that means whatever that is coming in front of it should
    be used as it is, rather than, rather than considering that that's a special string defining
    symbol. Now in this particular case, you'll be having your double quotes available, and
    the backslash will be just out, it's justifying that don't touch this double code, it has
    nothing to do with defining a string. It is just because I want to highlight this word.
    Another more. Another more easy way is to use the single quotes, for example, we are
    learning and use the double quotes as a corrector. Inside that now the single quote, wherever
    it starts and ends, they defined the string, everything else is correct. We do not need
    a escape cracker where we where we want, okay, great. But there are a lot of escape characters,
    for example, we have V, our backslash n, that means go to new line, we are now on an other
    line. So this backslash n actually puts everything that comes after to a new line. That's an
    escape corrector. Similarly, we have an escape corrector, backslash D, that actually inserts
    a tab. Whenever we want Sophie, then a tab then now on another line, now on another tab,
    whatever. So there are a lot of escape characters. I'm in backslash, N, backslash t there are
    other. So it is good to know those. One more thing that is important. For example, let's
    say you want to print. Let's say you want to print some address on the right, let's
    see, Mac's slash back slash forward slash whatever that is called name, backslash Dr.
    Let's say you want to do that. And your goal was to just print that box, what will happen
    is this backslash n will be treated as a newline escape sequence. And backslash n will tell
    Okay, go to the next line and create the rest of the things. But because backslash D is
    not any escape sequence, it is not listed inside, it is treated as it is and that way
    this slash is also treated as a director. But here because if this slash followed by
    this n, that's combination that is already there for a new line that is treated in a
    different way. If you want this to be used as a deus and you don't want these, you don't
    want this behavior, you just want that all this should be greeted in a very literal or
    raw sense, then you should just apply and are there in our will tell, okay, that's,
    that's a raw string, everything inside just treat that as a raw string, there is no escape
    sequence inside. Great. So and there is much more about strings, we can talk but that that
    was the most important that I that I told you, at least to me, we can explore this more
    actually, you should now explore the smaller What are other functions of string, how can
    we play with strings in another way and stuff and
    so on. If I talk about strings, I can just I mean, I can give a whole course on strings
    as well. But here I just give you a snapshot of strings. If you need more about strings,
    I mean you should be searching on internet of seeing documentations and seeing basically
    what you want according to your requirements, search the functions probably they will be
    available. Okay. In the next video, we are going towards list topples, sets and dictionaries
    some other data structures that we were talking about earlier, we will be going to explore
    them in more detail from the next video. Hope to see you in the next video data structure
    informally or in a very naive sense is basically a collection of a lot of basic data types
    that contains data one structure contain a lot of data. And we can define sometimes several
    methods and several specialized kind of functions are customized and define just because of
    that data structure to perform efficiently different kinds of I mean for different kinds
    of tasks, we may have to define or we may have to choose different kinds of data structures.
    The basic data structures that are available in Python is a list tupple set and dictionary.
    These are the basic data structures that are available. We can create our own data structures
    if we want to. But most of the problems almost all of the problems mostly they are solved
    by these four basic data structures. Although a lot of these are not that efficient. There
    are efficient ways for customized kind of problems, we will see that efficiency when
    we will deal with the package NumPy that is, that is faster than all of these, but will
    but we will see what kind of constraints are there to make it faster. Anyways, data set
    in a very loose term is collection, it is a collection of a lot of values a lot of data
    inside. And all these data structures list tupple set and dictionary, they they are a
    collection of data of heterogeneous types, which means one value can be integer another
    element let me call an element, another element or item, another item or element can be of
    string type, another element can be off, let's say floating point number another element
    is a whole list itself another element is a topple and so on. So different elements
    can be of different types. And that makes this heterogeneity that makes these four data
    structures much more applicable and much more abstract. And they can be applied to almost
    all the problems. So let's see one by one and let's compare them together because the
    best way to understand four of these is just to compare them which can do what as compared
    to the rest. So let's let's compare them and learn how can we use those in detail. So list
    first is list list is ordered ordered here means it is indexable which means there is
    a particular element number one is at position one element, there is an ordering of elements
    first element second third 25th element, there is an ordering of element with respect to
    their position. So that's what we mean by ordered changeable or sometimes called more
    more reasonable term or more usable term is mutable. mutable means once the list is created
    as contrast to string, once the list is created, you can change its elements for example, you
    can change the third element with another element and that's perfectly fine you can
    change it that what we mean by changeable or more popularly called as mutable duplicates
    means the list can contain more than one one element more than two, I mean, at the position
    number three, you can have the same item and position number five you can have the same
    item that so the duplicates are allowed tupple however, although ordered, there there is
    an ordering of elements there is there are indices of different elements, this is immutable,
    you can once topple is created like strings. Once the template is created, you cannot change
    different elements in the tupple you have to create a new topple if you want to, but
    you cannot change the items in the tupple and the duplicates are allowed again set on
    the other hand is unordered which means there is no indexing there is no positioning, there
    is no first element there is no third element, there is no Fifth Element, there is that's
    a collection without it without actually indexing
    because you cannot access a particular element with index you cannot change it, but what
    you can do it you can insert more elements and you can remove existing elements if you
    want to. Again, the set like in mathematics sets does not contain any duplicates. So one
    item appears just once we will see the examples Dictionary of very, very, very powerful data
    structure. Again, it is it is dictionary is just like a set, it's a set it is unordered.
    Again, chancer bow, you can change them but you can change the items you can and the dictionary
    the pocket and it does not have duplicates, because it's it's basically a set it is just
    like I said, the power of dictionary is each item consists of consists of a pair and one
    one value in the beer is called key and another is called the value for example, well is key
    for 12 name is key for band and and so on. So we have seen this dictionary before in
    loops and stuff in just a very loose way. But then that's really a very, very powerful
    data structure. And later on we will see in pandas basically all the data is basically
    managed, just like a dictionary if you if you have a good knowledge of dictionary, you
    will be having a very good grip very quickly on on a Big Data Science Library or Big Data
    Science package which is called pandas because each and everything in pandas is handled just
    like you're handling a dictionary. So it's it's a really powerful data structure to know
    about.
    So, so so
    list is mutable dictionary is mutable set is mutable, in a sense that you can insert
    and remove elements. topple is not mutable. And that's a comparison theoretically What
    is there, all these types, each and every of them is a collection of different values.
    And the values can have different types. That's the that's the abstract power of all these
    data structures. So, in the next video, we will, we will, we will actually try to get
    a good grip on list topple set in dictionary and we will actually define them code and
    access different methods of those and we will be we will be trying to become comfortable
    with with these data structures by coding them in Python. So hope to see you in the
    next video. Okay, continue in previous video we were talking about data structures in the
    last video. So let's go to the Jupyter Notebook and see how a list can be defined or declared
    how a tuple can be defined or declared set and dictionary, let's see how can we make
    these data structures in Python? So then one by one, we will compare how can we access
    elements of the list? How can we insert more elements in lists tuples are in dictionary
    and and see the comparisons of all these one by one operation by operation. So let's see.
    So let's go to Jupyter Notebook, our friend this file is getting lengthy, lengthy, let's
    let's make multiple files. Let's say this is part one. Just save it. And let's make
    another let's make another file. For example, let's just close this file, or maybe state
    opened, let's close this file and make another file. Python three. Yeah, so let's name that
    file as this part two, let's start a new file that that file was on in that was okay to
    stay with that file as well. But just let's make another file. Okay. So that's just have
    a markdown cell. And let's have a heading. data structures. Remember the markdown cells,
    I just introduced them introduce those just in the very beginning. And then we just forget
    them. Because writing these description again, and again, we'll make the video length here.
    And the purpose is not to actually format the notebook, the purpose is just to show
    you the power of Python. So I just omitted writing these descriptions more and more,
    but just write a few descriptions in the star and then we will forget again. Oh, that's
    it. That's amazing. Let's see, find a list. So list. Any variable name, that's a variable
    in the list is, let's say this. You define this by square brackets and different elements
    they are separated by comma, that's a 134, point nine. Name anything I mean, or five,
    or maybe maybe three again. So that's the list. Okay. ductile, on the other hand, is
    defined using parentheses. So let's say 134. point nine. That's the name. And that's a
    three again, that's okay, that's a tupple. A tupple is defined in. So when you write
    parentheses, that means by default that topple the variable name has I mean, if you have
    written t that has nothing to do that it's a tupple. That's because the Python is dynamically
    typed. When you will write the parentheses that means the tupple is being defined. Let's
    define a set Let's call the variable as S, the set is defined with with these curly brackets.
    So let's say 134.
    point nine, I want to tell you that all these things they can contain each element can have
    a different type. But then, even if we include this three again, because the set cannot contain
    the duplicates, later on, we will see only one copy of three will be there in the set,
    the other will, even if we want to include it will not be included. Okay? Then let's
    say a dictionary. dictionary is again defined like a set, but but each element is a pair,
    separated by a colon. Let's say the key value is 23 as a key value, that's the key and the
    value. Here is a string, let's say
    two,
    three, that's let's see the value. Now comma. Now one element is there. This one element
    that consists of key and value pair, another element, another element may have a key with
    string. So so the keys can be of different types, the values can be of different types,
    and so abstract. So the key is, let's say, let's say B. and the value for this is, let's
    say 43, then maybe we can have another key value pair with key as, let's say, c. and
    the value is, let's say, cc. CCD. That's a charge coupled device. Okay, anyways, so.
    So again, now you know how to define less how to define a topper, how to define a set,
    and how to define a dictionary. The difference is, is the main difference here is in dictionary,
    because one element consists of two values rather than one. Okay, let's print that and
    see the types let's print all the types sprint died off. So let's paint them. That type of
    L is. So the table L is just printed. That's L, let's print that. Let's see the other types,
    let's print the rest as well. So just copy them and B is the type of list L is that the
    type of topple is D. And that's a D, then we have s and then we can just replace this
    to the s. And then we have, let's say, D dictionary. And that's, that's D. Okay, so that's been,
    so the type of L is less the type of t is topple the time of s is set. The dive of D
    is dictionary. Oh, great. So that's how you can define these lists. You can define list
    you can find topple, you can define set, and you can define dictionary, no problem. Next,
    let's see how to access different elements from from these data structures. What are
    the way for example, to access an element from a list, let's say the element number
    element that indexed with one remember the element that index with one is element number
    two, because indexing starts from zero. So you can access that using the square brackets.
    If you want to access from topple again from the square brackets exactly like the list.
    In set, for example, you cannot index it because the set has no ordering. First, second third
    element is no longer there. But you can you can, you can check whether a particular element
    is there in the set or not using in keyword. In dictionary, for example, if you want to
    check whether a particular element or if you want to access value, for a particular key,
    you just create the dictionary variable name and then write the key and it will return
    the value. Okay, so let's practice this in in Jupiter. Let's just practice this in Jupiter.
    So let's say list value at index one. So that's brand new, this list added next one, the value
    should be printed as three brand topple at index one, again, the way of accessing the
    same Brent Brent, whether three in s or not, the return value will be the return value
    will be true or false. So print will be true or false. And then print the and just access
    the value with the key 23. So let's see what happens. So l added index one is three tier
    index one is three s, three years in S Yes.
    And what is the value with the key 23? The value is the value is two three. Let me just
    describe more about this D. What is the value at index B for example, now we have to give
    the index B in the string format. That's 43. Yeah, so that's how we can access that. Let's
    sprint s also let's see s because when we have defined as we have defined this duplicate
    three But if you see the elements of s, there are no duplicates. And it does not maintain
    even any ordering, I mean, we have defined s in a different way, it is maintaining everything
    maybe in a different way, one three. Yeah, oh, the ordering this way is the same, but
    there is no index for the first or second or third element and so on. Okay, so that's
    about the defining, declaring or accessing different elements. In the next video, we
    will see more about about the data structures actually, actually want to spend some time
    on the data structures because that will be a basic building block for for the data science
    packages, too. If we if we know very well about these data structures, these data structures,
    we will be very fluent in the data science packages and working with those. Okay, hope
    to see you in the next video. Okay, in the last video, we define less topple set and
    dictionary and we actually access different values. In this video, I'm going to actually,
    I'm going to actually introduce more indexing, how to access list and topple in particular,
    because the both are very, very easily indexable like strings. And I want to show you that
    all kinds of indexing that you have seen in strings, exactly works and list as well as
    in tupple. So let's go to Jupiter, and see what a list is, for example, a list, if you
    print the list, that's the list, it has these kinds of values, if you just see the list,
    for example, starting from index one, ending at index three, that that means the same big
    a slice for example. So index one value is three, index to value is 4.9. And the last
    element is not included. So, if you get that you get three and 4.9. So exactly the same,
    the same kind of indexing that you have seen in strings, exactly there is working here
    as well. So for example, if I say list, start from the beginning go to N but then I just
    give minus one it will reverse the whole list, I mean the whole list will be reversed. I'm
    in all the same all the things that that we saw in in string indexing stays exactly the
    same in list as well as in topple, so topple For example, let's access element from let's
    say from the very beginning till the till the third element, that's not the third element
    till index three, which is actually the fourth element. So topple unless they are exactly
    they will be exactly index as as it as it is. So all the slicing all the indexing all
    the sub sub listings, all all the sub topples, they can be accessed exactly the same way
    as you as you've gone through through the through the strings. One difference here that
    I will explain later on, because list is mutable it is changeable, I will discuss one thing
    that one use when you slice it, when you get a sub list then actually it refers to the
    same memory and if you change the sub list contents, the actual list chord changes. That
    is that is true for list in slicing. And that is true for sets and dictionaries, in the
    copying the references and so on. So I will discuss that later on. But rest of the things
    are roughly the same as as they're in string indexing. Actually, indexing is almost the
    same everywhere in Python, it has this kind of slicing is almost the same if you know
    the index, how to index planes, you know how to index lists, if you know how to index lists,
    you know how to index couples and strings and, and everything. And by the way, if you
    know how to index strength lists, you will be very fluent and NumPy. That's the very
    powerful data structure. That's very powerful kind of array processing package. with with
    with some defenses that we will see but
    even the indexing is same in pandas when you are working with large amount of data data
    file and stuff like so the indexing is more or less the same that you've seen in instruments
    we will we will cover indexing, masking and fancy kind of indexing in much more detail
    in NumPy. But this stays the same as, as you've seen in in, in strengths Okay, so now can
    we can we expand the list can we add more elements? Can we insert more elements to the
    list? The answer is yes. Because list is changeable. New trouble you can insert more elements.
    One way of inserting there is just to call an add operator, you can just add plus and
    you just insert in other lists like like two strings are concatenated by plus two lists
    can be concatenated, or combined together again by plus, but there is a faster function
    called append l dot append. That is sometimes faster than using this operator we will see
    that topple because it is immutable. You cannot touch any content of the double you cannot
    actually insert any element to a topple you cannot delete any element to a tupple. There
    are workarounds for example, convert a tupple to a last change it then convert the list
    to a tupple. There are ways to do that. But tupple in its true sense, in the literal sense,
    it is immutable. You cannot insert any elements you cannot delete any element you cannot change
    any element. However, you can combine two tuples. Together, you can concatenate two
    tuples together again by plus operator and save the result into a new double that's possible
    set. The you can insert elements using an add function add function allows you to just
    insert one element. If you want to insert more than one elements, then you can call
    an update function that actually accepts more than one that accepts another set that need
    to be inserted. That's possible dictionary, you can insert a new key by just the new key
    equals to that you just assign a new value to a new key and key value pair is just inserted
    there great, you can delete or remove any element from the list using D l Command D
    l l one that means the this particular element is deleted from the list that is possible.
    Deleting particular element from the tupple is not possible However, you can delete the
    whole variable whole topple that is possible, you can remove elements from the set using
    remove function as dot remove, and then you just give the element that you want to remove
    that as possible, it will be removed and you can delete the whole delete the whole variable
    that is always available. Similarly, you can delete a particular item from the dictionary
    by just deleting by just calling the D of the value for example, whatever the key is,
    so you call with the key and call the Delete and it will delete everything I want to mention
    here for to remove items from the list there are other methods and functions that are also
    available that I mean there is a remove function, there is a pop function, these are available.
    Similarly, from removing elements from the dictionary, there are other functions that
    are available. But just to compare them together, I am using this de l command, although there
    are other ways of doing the same stuff, as well. So let's let's let's let's end this
    video here. And in the next video, I will show you all these operations that concatenating
    together, inserting more elements, deleting different elements, I will show you all these
    things in in Python. So So hope to see you in the next video. Okay, in the last video,
    we saw how to insert different elements to different data structures. And we for example,
    in the case of tuples, it is not possible. And we also saw how to how to actually delete
    different elements wherever possible. So let's go to our friend Jupyter Notebook and see
    all these concepts in a running form. So let's go. Okay, so let's say for example, we have
    list, that's our list. Let's append an element to the list or maybe more elements, that is
    L plus. Let's say we can have another list for example, how
    are
    that's six, and then you that's and these two lists will be appended and the new list
    will be as you can see this similarly we can append an item using append function for example
    6.8 that will also be appended and this will contain these kind of values. So yeah, so
    both arrays are fine. This plus is this plus can be used to append to append to lists and
    this append function can be used to simply append a list with a with an element. Okay,
    great topples. You cannot change the topple, you cannot change the topple. But what you
    can do is you can have two tuples for example, T two is a different couple. Let's say a A
    and B, and let's say you have four or five, that's it that's supposed to, then you can
    have a third double, that is just the combination of double one and double two. And in this
    case, you have double three, which is this. Yeah, so double one and double two are combined
    together, but you cannot actually insert into the assembly, the tuple is immutable, you
    cannot insert another element, you cannot delete existing elements, you cannot update
    any element and so on. Similarly, as the set, let's see the state of the set, that's the
    set set God add function, you can add anything, let's if the six that is added there, and
    the new state of assets this, or you can call the update function. If you update method,
    if you want to insert more elements, for example, if you have multiple elements to be inserted
    23. Again, and let's say you wanted to insert an element that is already there. So for example,
    one, then the duplicates will no longer be there, but the new elements will be inserted.
    Now let's see the state of D, the state of D is this. If you want to add another key
    value pair, you can add a key here, for example, the key might be new key, for example, new
    key and the value might be the value might be, for example, a new value. Well, and now
    if you see D, the D, the contents of the D has changed. Well, that's simple. Yeah, great.
    Can you concatenate two dictionaries together using a plus operator? Is it possible? Is
    it possible to concatenate two dictionaries together? Let's see I have another I have
    another dictionaries dictionary D two. That is that say the key is why. and the value
    is why why? And then we have another key letter Z. and the value is. Let's sit down, can I
    can get an A D and D two together? Can I? Can I just update my D and add these values?
    insert these values also there? Okay. I left you with this question. You try to answer
    this. And in the next video will answer this question. But try to answer this question
    yourself. And one way to try that is just to go in Jupiter and just dive and check whether
    plus is working or not. Or maybe there is another method and stuff like so. Okay, great.
    Hope to see you. Oh, I have not used the D l delete and all that stuff, and so on. So
    this question is there, let me use the removing the elements. So let's say l is this list.
    If I want to remove an element, let's say element number three, if I want to remove
    element at index three, which is this string name, I can use simply this delete. And the
    L is everything but without that element. Similarly, I can remove if I want to remove
    any element from S, I can call the function remove. And whatever I want to remove, let's
    say want to remove game, and the game will no longer be there.
    Great. If I want to remove some element from dictionary, again, let's say that's the that's
    the view of dictionary. I can call the Add I can I can remove the element with key let's
    say C, whatever the element is with key C, delete that element, and the dictionary has
    this particular state with this item, this particular item is gone. Okay, great. I can
    do that. But But d L is not the only way of doing that. There are so many methods. I mean,
    a lot of methods to do that. But just to just to compare all these, I'm just giving you
    the most similarities and differences wherever available. Okay, great. So I have asked you
    a question in this particular video. Can we concatenate two dictionaries together, particularly
    with a plus operator? If yes, then we are done. If not, then Are there other ways and
    stuff like so that's the question. So hope to see you in the next video with more on
    these data structures.
    Okay, I asked you a question last time. Can we concatenate this two dictionaries together
    with a plus operator? So what's your answer? Yes or no? The answer is Nope, yeah, so we
    cannot concatenate them together, we cannot insert another dictionary to this dictionary
    using a plus operator. Because this plus operator is not defined for dictionary, what we can
    do is we can call an update function, because dictionary is also a set, I mean, a set of
    key value pairs. But at the end of the day, it's a set with specialized function, of course,
    but we can call update functions, and insert the whole new dictionary inside dictionary
    as as as follows. Yeah, so the answer is using plus operator No, but there is a way using
    update method. Right. So next, we focus on the copy function, the copy function is available
    for less the copy function is available for set, the copy function is available for dictionary.
    So let's see the need of this copy function here, I want you to be very careful. Because
    that's, that's really important. Let's say we have a list, let's say, That's list. And
    by the way, the same goes with set and dictionary as well, whatever I'm going to do with list,
    let's see a list. Now, what you do is you copy the list or you just make another variable,
    like you can assign the value of l to another variable l two, what you do is that now l
    two is also has this, now these are two different variables, L is this variable, l two is this
    variable. So you might be thinking l two is separately a completely a new thing. And Alice
    new thing, you might be thinking that both are independent. But Python internally manages
    the data structures, most of the data structures in a way that because the data structure is
    a collection of a lot of data it has it is consuming a lot of memory, what it does is
    when you assign a variable, or data structure to to another variable, it does not actually
    copy all the contents, it does not actually make a new memory, and store the contents
    in this. It actually this variable also actually points to the same memory as this. and and,
    and and the consequence of that if you change any value, for example, in L two, let's say
    you change the index to value from this, the index to values 4.9. Now you're working in
    L two, let's say you change this L to value from 4.9. To Let's 4.9. Let's see you do that.
    So you might be thinking that this happens in L two, well, in L two, that has happened.
    But what it also does is it does the same thing in L as well. So l also changes. The
    reason is L and L two, they both are pointing to this structure in the memory. And whether
    you approach that structure through L, or you approach that structure two l two, you're
    approaching the same memory anyway. And that is called referencing I mean, it does not
    create the data, it actually create a reference in the memory to actually create a new name
    for the same memory. And both are pointing to or accessing to the same memory. And if
    you really want the behavior so that l two becomes different than L and what I what I
    do with L two, that should not affect L, then you should call copy function. l two is L
    dot copy. Yeah. So that's the function, I'll copy. Now you have l two. Now you do whatever
    with L two, it will not affect L. So l two, for example, index at index two, you again
    say okay, this is 4.9. So l two changes. Now, l two changes, but l doesn't change, l doesn't
    change, l stays the same. Now this is different copy, same concept, go with the set. And same
    concept go with with the dictionary. If you if you just make another way will s two n
    equals two s, then if you change the contents of s two s will change. If you don't want
    that, then copy it similarly copy the dictionary, because the contents of the topple they are
    not changeable. The copy function is not available for double. Because even if you assign this
    T to T two, you can now not change D two because it is immutable. So having a copy function
    doesn't make sense in tupple. Wait.
    One more thing regarding slicing. Let's say you have let's say you have Dell that's available
    to you like so that's L and let's say you make l three another list by slicing Let's
    say a list from let's say one to five, let's say. So you start from index one, which is
    three, and you go to five by not including five, this way, the L three is automatically
    a copy, it is not a sub list, which is referencing. So l three. So l three is a different l two
    is a completely new list, a new memory view, if you change the contents in L, three, if
    you change the contents in L three, for example, l three, or index zero, it should go from
    three to let's say, three, if you change the contents in L three, these contents, these
    change will not reflect an L. So if you do the slicing, slicing picks a copy by default,
    it does not pick a reference. And that's a huge difference between this list and a NumPy
    array, when you end it, we'll see that when we will see a NumPy array, the slicing actually
    also, again refers to the same memory location. And that might be one difference in indexing,
    indexing in the whole Python, whenever you do slicing, you get a copy. But in NumPy,
    when we'll see NumPy in detail, in NumPy, when you do slicing, you get again a view
    not a copy, and if you change in the slice torian anything the actual the actual contents
    also changed. And there is a reason to do that there is a there are efficient reasons
    to do that and stuff like so, again, the dot copy function becomes the copy function become
    much more applicable there as well. So, so, so you need to know that even if you do if
    you do slicing in general in Python in any collection in any array, in any, if you do
    select a collection for even for mutable objects like list, you get a copy, but in NumPy array,
    the things the things these things, this particular thing with with a lot of other things this
    but this indexing scheme actually changing, changes with with this kind of slicing. Okay,
    so I am this video here, I mean, you can explore much more functions of lists tupple, seven
    dictionary and what you can do with each of them, and what you I mean, in which scenario,
    what kind of thing is more suitable for the other that completely depends upon the problem
    at hand. But what we can do in what what we will do what we'll be doing in the less next
    video, we will be seeing some using some functions of just list. And then I will be just just
    letting you to explore the the tupple set and dictionary and all their functions on
    your own. And to see what function or what method is doing what for what, which kind
    of data structure. So in the next video, we will be seeing some methods just for list
    data structure. Hope to see you in the next video. Like in screens. Let's Let's explore
    a lot of functions in list. Although in, in in sets and dictionaries and tuples tuples,
    as well. But many more functions are available in list. And by the way, let's see how many
    things are there in this list. And let's say l dot tab, and tab will open up a lot of things
    with me for me abanda we know already clear copy, copy, we know already count, we don't
    know count, extend, index insert, pop remove reverse some of these functions. They make
    sense by the adjuster name. But let's see one by one. Let's see some of those. What
    they do. One way to do that is go to internet and see some book or tutorial or something
    like So another way is just write this apply. Maybe, maybe help function maybe apply a help
    function, it may help you how to use that. Great this help function is great. So abandoned
    object method of building list in stance about an object to end of the list. Oh, it appends
    an object to the end of the list. Which means
    we may be able to append another list to to a list maybe. Have you thought about that.
    The append method just takes 111 object. Maybe it takes a whole lot of list. But then it
    may be possible that a list is appended inside another list and that whole list becomes becomes
    one element because list can contain other lists as elements are that's a problem. Yeah.
    So let's see more functions. Yeah, so let's see clear what this clear What is this clear
    what it does? Sometimes I use help, sometimes it's used that remove all items from the list,
    oh my god, if you call the clear that the list is empty, okay? If you just call clear
    function on a list will become empty. Be careful. Okay, great. What else? So that see I have
    this function maybe, Bob, what does Bob does watch. So let's see. So Bob removes and returns
    item at index defaulted the last, which means if you also that's the default value remember
    the default value. So, if you call a part function without an index, it will return
    it will remove the index it will delete the last item and it will give you that it will
    return that are if you give an index, it will remove that value at that index. And it will
    after removing it will return you that. So you can use it wherever you want. So there
    are many more functions for example, you can see all of them one by one remove function,
    for example, reverse reverse, like, like, like the name suggests, if you call the reverse
    function, the list will be reversed. Yeah, and remember, we have reversed the list in
    the following way as well, we have a way of reversing any way, this way. So now if you
    see the list is again reversed. So I guess both of them are working like so same. Similarly,
    you can explore several functions from a set, you go and say add Clear. Clear might be working
    as same as intersection intersection and update is destroyed is a subset of the other. Yeah,
    add by default or update by default, actually take a union. So I'm not seeing update function.
    Here it is update. Oh, union is there update is there, which means the list you're seeing
    is here is not a complete list you may be writing, what are the functions that start
    from you. So here are the and and several others. Similarly, you can go to dictionary
    and call for several functions clear copy from keys get items. That item might be might
    be interesting. What is this item? what it does? Oh, it has an error? What? So how can
    you use this? How can you use this function? Let's see, oh, this is just an object, it
    is not a function? I don't know.
    Let's see again, are it is not listed anywhere? Oh, it is items not item. Okay, items. That's
    a function maybe. So these are all the items 23 with this, be with that new key with that,
    and so on. Great. So actually, the purpose here is not to tell you each and every function,
    what it does, it will take a whole lot of time. You can go and explore all these functions.
    The purpose here is to tell you what kind of data structure has, what kind of properties
    and what are the similarities and differences in between. So if you remember this one slide,
    for list, double seven dictionary and some text that is written out above, you'll be
    having very good knowledge of where to pick what kind of data structure in practice. So
    in the next video, I'll be actually going to Jupyter Notebook as our as our style and
    I will be coding or solving some problem for you that will involve list topple set or dictionary
    are one of them or we will be choosing based on problem what kind of data structure is
    well and what so we'll be doing that. But before that, I just want to I just want to
    I just want to mention that list tupple set or dictionary they can contain any items inside
    any kind of type, which means a list can contain another list. A list can contain a set a list
    can contain a dictionary, a list of dictionary can contain a list which itself contains a
    dictionary, I mean, this is all abstract, this is all abstract, one thing can contain
    the other one thing can contain an instance of I mean, a list can contain multiple lists.
    And those lists can contain more or less and so on. So before actually going to problem
    solving, let me give you a flavor of that how abstract these things are. Let me give
    you a flavor of that in in just just in a couple of examples. So in the next video I'll
    be giving you a couple of examples based on the abstract mess of these data structures.
    And from the next next video, we'll be probably, we will be doing some problem solving based
    on that. So next two videos are completely on Jupyter notebooks. So get ready, I hope
    to see you in the next video. Okay, let's see the abstractness of all these data structures.
    Let's see just one example. Let's say we have l as the list, we have all rich top all that
    stuff. So let's say we have set that set, let's say n, we have dictionary, that's a
    dictionary. Okay? So let's say we have all these things that say available somewhere.
    So let's make another dictionary. For example, let's say D, D, Ma, that's a D tool. And that
    dictionary has key value pairs less The key is a and the value is whole list l master
    value is possible. Let's say the key is B. and the value is just to topple the whole
    topple, that's the value. Let's say the key is C, and the value is the set. And let's
    say the key is D, and the value is the dictionary, the whole dictionary D it is possible. I mean,
    you can just do that, that that is just one example, oh, what's Oh sorry, I should have
    I should have incorporated this way. Okay, so this is possible. Now, for example, if
    I access, if I access the element with, let's say, a, I will, I will get the whole list.
    And not only that, I can again access the whole element. And then after that, for that
    element, I can access for example, the third element, the element at index three. So this
    particular, this particular first level will extract the list. And that will in that is
    just the indexing or for that list. See, for example, if
    I access D two, and inside the tool, if I access the dictionary that is inside, and
    let's say I save that dictionary in k, then it I can see the contents of K but I can just
    for example, this or I can just access all elements of this dictionary, or k by just
    having 4x in gay brand, for example, x and k of x, just do that i can i can just do that
    we have done that in loops as well. So I want to tell you that the these even if for example,
    if you want to create a list l let's say l three let's say you want to create a list
    that can contain a whole list that can contain what will get Oh, I mean one element is the
    list another element is to pull another element is the whole dictionary inside and then you
    have some other elements let's Lee's game and that's perfectly fine i get i mean you
    can do that, these data structures are much more abstract I mean now if you for example,
    access element at index two which is dictionary, that is completely a dictionary if you if
    you check the type of that element that that will be a dictionary object and you can extract
    that element and play the way you want to play and whatever. One more thing if you can,
    for example lists we can let's say we want to make a list list very quickly for example
    list off all the squares till till starting from zero list of all the squares till till
    10 for example zero square one square to square let's say we want a list of that. So one way
    of doing that is a quick shortcut is to just use the loops so in loops, for example, we
    right okay, x square for x in range. Then for example, so it will start from zero go
    till nine, including nine and you will get x one by one. And all this index is for making
    a list of x squares where x starts from zero and go to go to including nine go to nine
    one by one and that's how you can make a list and I'm in these kind of these are kind of
    shortcuts. Again, you can make a sale For example, let's say you want to make a set
    of all the squares for x in range, let's say, starting from starting from two, ending at
    20. And you want to take a step of, let's say three. So, start from index two go till
    20 do not include 20, but take the step of three, and you can now have a set, which is
    which is this. I mean, there are, there are a lot of ways of working these working with
    these. One, one can explore more and more about these things, but what what what the
    basic thing about these data structures are, they are very, very abstract, they can I mean,
    a list can contain a dictionary, and that dictionary can contain a topple and that will
    have an element which is another list and so on. It is that abstract, it allows you
    to do each and everything in that way. Okay, so I end this video here in the next video,
    we will actually solve a problem using these one of these data structures or we will try
    to choose one of those. And that video naby lengthy may be small, because we may have
    bugs inside. And we will we will play around with these data structures in the next video.
    So do attend the next video because it's really the practice and you will get your hands you
    will get a very good grip on the data structures in the solving the next problem that we are
    that we are launching for you, okay, hope to see you in the next video. Okay, let's
    see a problem just to get comfortable with these data structures. So let's let's design
    some problem and solve that problem here using using these data structures. So the problem
    that I'm thinking is, let's say the following. Let's say let's say you are you a teacher,
    should I type all these things? Okay? Let's say you're a teacher, you are a teacher. And
    you have
    different student records to learn records containing containing ID of a student and
    the mark marks list in each subject, where different students have taken different number
    of subjects. And all these records all these records are in hardcopy. You want odd copy,
    you want to enter all the data in computer and want to compute the average marks of each
    student. And display. That's the problem. So the problem let's say is, you have for
    example, you have a hardcopy you have you have some papers, upon which you have different
    students, each student have a different ID. Some students may have taken seven subjects,
    some student may have taken three subjects, some student may have taken eight subjects
    and so on different students may have taken different subjects. Regardless there, you
    want to first enter each for each student, you want to first enter the records, I mean
    all the data that is in and then you want to compute from that data, you want to compute
    the average marks of each student. For example, if a student have taken five subjects, then
    the marks for all the five subjects are available, you just add all the marks and divide by five
    and that's, let's say, the average marks. So first of all, let's ride away two way to
    compute for example, the to just collect the data, how to collect the data. So let's write
    a function for that. So let's say define a function, let's say get data From user or
    teacher, let's say, let's say that function, and it returns data. Okay? So what I do really
    is I say, okay, while
    true,
    I made a loop while true, just take the data from the from the user, and the data is in
    the form of you first say, okay, ID, student ID, let's say that is inter, or actually input,
    enter student ID. So he enters the the person enters the student ID. Yeah. So adopt, you
    might have define a dictionary, maybe a dictionary D, that is empty right now. But you may, you
    may add and remove different values. So what you do is, you add a student ID, you get a
    student ID, and in the string form, and then you get the you get, for example, the input
    as the marks list. So marks list as input. Enter the marks,
    by
    comma
    separated values. So enter the marks using for example, if you have five subjects, just
    write the five subject marks by separating each with the comma, okay, then this, let's
    see
    more
    students is equal to let's say input,
    enter,
    yes, or no.
    for
    adding more students, so if for example, you have more data to insert, then press Yes,
    otherwise personnel. So that's, for example, our setup. So we will keep on getting more
    and more, we will keep on getting more and more data from the user user will keep on
    increasing the data. But one thing that we must know is that if for example, a student
    ID, student ID is already in D, if that is already in D, then we should give a message
    brand. brand that student ID is already inserted. So that might be a message else. ls we want
    to do something else, what we want to do is the following. What we want to do else is
    we will make a dictionary, we already have a dictionary with a student ID as our key,
    that's our key. And at that key, what we do is be the pick the marks list, and just split
    it using comma because you're expecting and all the marks they will be saved as a list.
    So that will return a list. List of string values. These are not indeed values, these
    are string values. But all these lists they are tagged by this ID. So that is a dictionary
    that will be that we'll be getting populated on and on and on. Further if we check F for
    example, more students dot lower, for example, let's call the lower function because the
    user may interest at a lower form or if that is equal to let's say no, that is equal to
    No, if this is the case, or if there is no enter for example.
    No
    inter no inter Know, to quit when insertion, insertion into node with insertion. So let's
    say that's your message. So wherever the user inserted, if that's a no, then you return
    the and that's it. Otherwise, you keep on moving. So that's the whole goal. So you keep
    on asking the, the, you keep on asking more and more values. If whenever the teacher enters
    a no, then you just return. Otherwise, you keep an up, you make another equation, you
    make another equation and keep on moving. That's how you get the data. So the data will
    be available to you. Once you are done with that, then after that, we will see how to
    once we have this data collected from the user, then we will see how to compute marks
    for each student individually average marks and so on. So let's just check whether this
    function works or not. So let's say we have our dictionary that says student student data
    is equal to get data from user, let's just call that function. Let's see what happens.
    Okay. Enter student ID, let's say ID is 12. Okay, in remarks by comma separated values,
    let's say, well, one, let's say
    24,
    comma 65, comma 87, let's say the first two in just the first tool and just have these
    three subjects, then internode width, so I will enter something else. And oh, what's
    the problem? There is a problem. If more students taught lower is more student is not defined.
    More student that's, I guess, more students, more student here, oh, the spelling mistakes.
    That's a huge mistake. So I just copy there, these bugs are there. That's part of life.
    Part of programming life, actually. So I guess now it will work. So let's do the process
    again. So 12, let's say, and the marks are the six comma 45, comma, let's say a bad subject
    with let's say, 13. into no to quit. No, I will intro something else, I will keep on
    moving. The other student is the student ID is 45, let's say. And the marks that this
    student has gained, actually, let's say this student has, has registered has already registered
    seven subject or let's say five subjects. And the marks are, let's say 44 to five, six
    to 677. And let's see a bad subject, let's say four. Okay, then internodal, quit. No,
    I want to insert one more, so do anything else other than No. So student ID, let's say
    now the student ID is 12. Again, let's say, let's say want to insert another ID again.
    And whatever the marks, let's say 45, and 45. Again, that's a now internode width, no
    something else. But now, the message is there, the 12 is already inserted, because the ID
    the key value index, now you cannot repeat, and so is the student value. So it does not
    inserted the because this may be my mistake, so it asks again. So now let's say I enter
    ID, let's say 23. That's the ID or maybe a different ID. That's the ID and the marks
    are let's say 45, comma, 45. That's it. And internodal grid. So let's say I enter No.
    And that's it. So now I have received the student data, if I show you the student data,
    that student data is student data. That's a dictionary, that's a dictionary with the
    with key 12. And that's a list. But this list contains all the values that are our string
    type, we will see how to handle that. That's a 45 as a key value, that's ID and that's
    the marks list. And that's the ID in that small list. Okay, great. Now we have student
    data. Let's write another function that helps us working on the student data, basically,
    we want to find out the average marks of each student. And then we want to print those.
    So let's define another function and get average marks of each student. And that function actually
    receives this dictionary, let me call it as D, any any variable, that's a local variable.
    Okay, so what we want to do with that is the following. Average marks for each student's,
    so we will define another dictionary, let's see everage marks dictionary, let's say that
    is empty in the beginning, maybe, and then what we do for x in D, let's icreate over
    x and d, what we really do is we go to the we find out the list of located at ELLs are
    located at x L is basically D sub x. So that's it, that's our list. That's our list that
    is located there. So then what we do for i in L. So for all i that is an L or let me
    call it for marks, marks in L. In this particular list, what you do is you actually have this
    sum of sum is equal to zero right now,
    there is no marks. So what you do is s plus equals two marks, but convert the marks to
    integer because they are already in string format. We have we have saved everything instinct
    string format, so you populate all the list. Once you are done with this loop, the S will
    contain the sum of all the marks, then what you do is you compute the average and just
    save that average in ABG. Marks decked dictionary, let's say on average marks, just just don't
    use the word deck, for example, you can but let's stay gradual and add x, you just write
    the average marks. And the average marks can can be computed by s divided by length of
    the list, whatever the list is. So that's what the list is. Yeah, so that's the average
    marks. And once you have an N one by one, all the average marks will be populated. And
    once we receive all these, we will then begin then we can then just display by populating
    the average marks. So let's see, let's call that function. So let's call that function.
    So ABG marks for example, equals to get a VG marks, and let's bond these student data
    inside. And if there is no error, then it will return everything. Then just print the
    average marks for each student for x in a Vgm. brand, let's say student and Brand X
    God average marks as then you just Brandt okay ABG m of x, x, and that will display
    everything Oh, if there is an error, non type object is not equipped. I prefer nine type
    object why non time object? We have done some mistake. Yes. Maybe. Let's see. Let's see,
    for example, when we run this, so let's run this and create a cell Let's run using alt
    Enter to create a cell everage m What is that thing? Oh, that's nothing. Why oh, we haven't
    returned anything. That's a bad programming. Really bad programming. We have not returned
    actually. The the value that we need. So the default value is none. raid actually not so
    great. Okay, great. You have this and now we have something in Emirates marks. Yes,
    this is and now we can just populate that and we have this student 12 got average marks
    38 student 45 core average marks 90 49.2 and student 20 He got average marks as 45.0 Okay,
    great. So that was just a review of split function of string, type and marine through
    int, and functions in general input function, and, and dictionary and list and all that
    stuff. So although it was a just a tiny problem, but it gives a good flavor of the data structures
    and strings and all that stuff. Okay, that's about the data structures. From the next video,
    we are actually diving into the data science packages. And we will start from NumPy and
    we will spend some time on NumPy and then we will be moving towards pandas, which is
    very, very powerful built on top of NumPy and after that, we'll be moving towards matplotlib
    and we will also try to give you some snapshots of psychic learn as well. So hope to see you
    in the next video. Okay, the next few videos will I will discuss NumPy which is the which
    is the very very popular package for numerical Python. Actually NumPy is like list but it
    is much much faster than list.
    One one restriction if we restrict the list of Remember, a list actually is a collection
    of a lot of data objects. That was so abstract, as we saw in previous videos, if for example,
    we restrict a list that all the objects they must have same type all elements in the list
    for example, they have same type then that list with all the same type, there is what
    the NumPy looks like, but NumPy is very, very more faster. And the reason is, even if you
    define a list with all the elements that are let's say of same type Yeah, but because list
    in abstract way can handle heterogeneous kind of objects, the functions that we will apply
    on these items, they will no longer be faster further to store each element we have to store
    that information or metadata for that element in NumPy, it is both I mean, it is efficient
    with respect to memory, because if the type is saying we need not to save information
    about each element, because we need just to save the information about the type because
    the type is same for all elements further when the type is same, we can write functions
    that are much more faster than then then a list. So NumPy is very, very popular, it has
    very very fast universal functions available the methods that are available in NumPy. And
    it's a package i mean it's it's a whole directory structure containing a lot of packages inside
    a lot of modules and so much at the end of the day, it's it's it's simply or in laymen
    terms, it is like a list with all the same type objects and it is much more useful when
    all these objects are numeric type, although you can have a NumPy array with with spring
    data types, I mean all the strings are all general objects as well, but the the most
    the power mill the power of NumPy array will be will become much more evident when we will
    be working on numeric type data. So in this particular in this particular course we will
    focus more on numeric data then other kind of data. So that's how you you write import
    NumPy is installed or if you if you have installed Python using Anaconda NumPy is already installed
    there it is in the side packages kind of a built in package. So import NumPy we can stay
    as it is but we can rename this NumPy just NP that's most popular name, we can write
    any other name but if you see the books or internet or somewhere this NP somehow becomes
    much more popular. Okay. Now we can define an array for example NP dot array that array
    is just a method of NP kind of function. And we can define an array using list this is
    the list of several numbers or we can define array as as a topple as well. So whether we
    give a topple whether we give a list an array is defined and then we can see the contents
    of this array, this NP array so let let's just go to our friend Jupyter Notebook and
    get our hand Well dripped on, on this NumPy. So first of all, we need to import NumPy package.
    And we may rename as for future use as NP. So let's say that is imported. So now let's
    say a is an array, let's say NP dot array, that's a function and we may have a list and
    say, let's say 12357. Let's say that that's right, we can also define the array using
    a topple rather than a list, it's our choice. Which way we define the array either way.
    235 Let's, that's, that's another array for example. So if we print for example, a it
    will give us a but if we just see the type of a it will no longer be list it will be
    an ND array numpy.md array that n dimensional array, okay, great. So, there are so many
    attributes of this a and this B. Same. Similarly, if you see the type of B although we have
    defined this be using the tupple. But the type is the same the it's a NumPy object rather
    than a list or a topple.
    So that's how you can create the the array 1111 more thing that is that is important
    is to check the attributes of a for example, k dot d type, that will tell us the data type
    in a so for example, a stores all the data that is integer 32. At defined time, for example,
    we can we can specify the data type if we want we can specify the type if we want. For
    example, in teacher that means as in teacher here, we can here we can define, for example,
    the type as float, for example, so data type becomes float. There are several other other
    options that are available to define the data type but, but even if we don't define the
    data type can be defined automatically based on contents. That's what the dynamic typing
    means. So if we now define type that is, if we, if we now check the type of a that is,
    again in digit 32, but if you check the type of be the type that that might be a float
    number, yes, that's float 32. Again, there are 64 bit support as well, I mean, we can
    define here there are several options here available. So that's the that's how we can
    define the NumPy array that's just getting started with NumPy array. In the next video,
    we will play with these arrays a bit more. So hope to see you in the next video. Okay,
    in the last video, I introduced NumPy. And we actually declared a NumPy array using a
    list as well as a topple. In this particular video, we will be seeing some of the properties
    of the NumPy array variable or sometimes called the object that variable there are several
    properties, but I will discuss for example, last time I discussed one property which is
    d type a dot d type, and that store actually the that actually stores the information of
    the data type of the elements of the array of NP array, remember NP array, all elements
    of NP array they must have same data type it cannot store heterogeneous arrays as it
    is. Okay. Now, there is another property sometimes called the dimensions are n them. That tells
    actually, what are the dimensions of of the array, I need to explain this term dimensions
    with the following example. Let's say for example, that's, that's that's an array just
    consider that a list for example, 123, that's one list. And if it is if it is an array,
    for example, if np.if this is NP dot array. With that list, we will say that array as
    a one dimensional array, because we only need one index to access that. For example, if
    you need to access any element in this array, you only need one index either 01 or two,
    only one index, that's okay. So in this case, we have just one dimensional array. On the
    other hand, for example, if you see here, that's one array or one list, that's another
    array, another list. And that's another list that contains lists inside for example. Let's
    say that array one, and that's array two. And that is simply an array of two different
    arrays. That's, that's an array and that's an array. For example, a One is this array
    and a two is this array. Now if we need to access any element in this particular array,
    we need two indices. First of all, we have to locate whether we are going to talk about
    a one or a two, we need one index for that, for example, if we want to locate a one, that
    means we are going to access with elements zero, let's say this, this whole array is
    a So first of all, we say okay, zero means we are going to access from from a one and
    a to one of those. So zero means the first one, okay, now a one. Now inside a one which
    element, this is the zeroeth element, this is the first element, this is a second element,
    let's say we want to access the first element. So that means we are going to talk about we
    are talking about this. So very loosely speaking, the total number of indices that are required
    to access an element inside the array is called dimension of the array. And m them that actually,
    that actually defines that that actually describes the this property, the total number of dimensions.
    Consider, for example, this is a 2d array or two dimensional array, let's head out to
    two dimensional array A one, and let that's another two dimensional array a two, that's
    another two dimensional array, a three, for example, and let's say this is an array of
    two dimensional arrays, let's say NP dot array. Now, that's that whole array, whatever that
    array is a three dimensional array. And the reason is to access any element, we need three
    indices. First index will define which one of these we are selecting, for example, let's
    say you're selecting that. So one index is needed that index is one for example, then
    inside this structure like so, we need two more indices to locate a particular particular
    index. For example, because it is a two dimensional array, it has two one dimensional array, so
    which one dimensional array you are, it has more, it has many one dimensional arrays,
    so which one dimensional array you want to pick, let's say the sixth one will index with
    index five, now you have located the fifth or sixth array. Now in that array, what element
    let's say the eighth element. So we need three indices to access a particular element. So
    the dimensions of this array is three. So let's play with that in Jupyter, notebook
    just to get more comfortable with with the term dimensions. So let's say for example,
    we have an array, let's say a is NP dot array. And let's say it contains a list, let's say
    123. And then we have another array, one dimensional array, let's say four, five, and six, that's
    another array. And that is an array of these two arrays. So that is basically a two dimensional
    array. It is array of arrays. list of lists, equal entries. So that's a for example, oh,
    what's the problem? Oh, we haven't imported NumPy, we should have. So import, import NumPy
    as NP? Okay, we need not to import that every time. Actually, I'm recording this video after
    a few after a few hours. And I'm really I have restarted all these things. So I have
    to import now for the first time. But once imported in the notebook, as long as a notebook
    is running, you need not re import anything. Okay, so a DOD for example, and then Iraq
    and them. So that is to hear because there are two dimensions. For example, if I want
    to access element number three, this element, so this element is located in the first array
    of the two arrays, which has so the first array, there are two arrays with index zero
    or one. So I am going to look into the first array, which is 123. And in that array, I'm
    going to look for the element number two element with index two. So that's how you can access
    the elements of multi dimensional arrays are arrays with more, more kind of dimensions.
    Let's say we have another array just to just to get more familiar with NP array, let's
    say, and we have a list. And that list actually contains that list actually contains three
    one dimensional arrays. Not only that, actually Oh, I'm confusing you a lot. Let me know Let
    me just, let's say we have 123. Let's say we have three one dimensional arrays. Let's
    say we have another 2459. The the sizes of arrays, maybe, maybe, maybe, I mean, maybe
    different. Yeah. Is that true? maybe different? Yes or no? Let's see, for example, the first
    array has size three, and the second array has total size. Does that okay? I guess, yes.
    And now if we want to access, for example, an element of an element with a, let's say,
    I want to access this element five, so that is in the secondary index with one, and then
    in that array, it has index two. So I've accessed this element, oh, we're not too many indices
    for an array. Why?
    Why is that? Why too many indices, for for an array, B selects a B dot n dems. And then
    that is one y one dimensional, I have to, I have this one dimensional array. And this
    is another one dimensional array. And I have made a list out of it. I'm in this is 1d array
    and another 1d array of concatenate them together, so I shouldn't have accessed this element.
    The problem is when you are going to define multi dimensional arrays, the the number of
    elements for each dimension, they should stay consistent. For example, if the first array
    has three elements, the second array must have three elements, or if the secondary has
    four elements, and the first must have four elements. If that is not the case, the array
    will not be defined like a multi dimensional array. For example, if we, for example, extend
    our first array with let's say, minus one. Now, B will be having two dimensions, no problem.
    And now we will be able to access for example, this element five, like so. So we will go
    to B again, we will see okay, select array number two, and in that array, select index,
    select the value indexed by two, which is five. So accessed no problem. And that stays
    true if you if you're going to define for example, a three dimensional array, let me
    just give you an example of three dimensional array that's a C equals NP dot array. And
    let's say we have one, two and three. And then we have another array, for example. 456,
    remember or so let's say that, that we can have one more for example, we can have one
    more list, why not? So let's say we have a 00 minus one, let's say, and that is what
    that is. That is a two dimensional array. That's a two dimensional array. Great. Let's
    say we have another two dimensional array. Let's say we have another two dimensional
    array with same kind of consistency, the number of elements and stuff. Let's say these elements
    are our minus of the, the other ones, let's say there's minus, minus, minus and this is
    plus one. And now we have this, if you see this thing, that's a 2d array. That's a two
    dimensional array, that is also a two dimensional array. An array of two dimensional arrays
    is basically a three dimensional array. Now, that's a three dimensional array. This one,
    C, so if you Oh, we have some, Oh, I should have defined this with commas. Rather than
    rather than spaces. Actually. Yeah. The reason I did that is MATLAB. I worked in MATLAB also.
    So MATLAB allows this space separated list, but I just confuse the things with with Python
    as well. But Python requires comma, they're okay. With MATLAB. By the way, just as a side
    note, MATLAB allows you to have commas as well as spaces, but this Python is just restricts
    everything to comma. That's great. Okay, that is C. So now, if you check c dot n them that
    is three, if you for example, want to access this particular element, what should you do?
    First of all, you select the, the one of the 2d arrays, there are two 2d arrays. So this
    is the first 2d array and that's the second 2d array. And if you For example, want to
    access this particular element, this particular element, which is minus three, if you want
    to access that, you first have to access one of the two 2d, two dimensional arrays.
    So let's access the second one with the index one. Now you are in this particular 2d array
    in that array with list which 1d array you're talking about. So I'm talking about the very
    first 1d array, so the very first 1d array is indexed by zero, and in that one D array,
    which element you are talking about. So I'm talking about this element that has index
    two in this particular array. So now, if you press enter, you will get minus three Wow.
    So that is basically how and by the way, you can make a four dimensional array, a four
    dimensional array will be an array of three dimensional arrays, and so on, you can make,
    you can make, for example, n dimensional arrays, and that's one reason why we call this as
    nd array, n dimensional array, not the type of C's nd array n dimensional array, you can
    add as many dimensions as you want. Great, we will continue exploring this NumPy more
    and more in in the upcoming videos in particular, I will talk about this shape property of this
    NumPy we have already discussed D type we have discussed and then in the next video,
    we will talk about shape and we will discuss more about about NumPy. So hope to see you
    in the next video. Okay, in the last video, we discussed this number of dimensions or
    ending property of any any NumPy array. And we also saw an example of defining a three
    dimensional array in Jupyter. notebook. Let let's discuss another property which is which
    is the shape property. Let's see what what this shape actually represents. So let's go
    to Jupyter Notebook and see what actually this shape represents. For example, you have
    seen this C as in the last video, we define the C as a three dimensional array that contains
    two arrays of 2d. And each 2d array contains three 1d arrays, and each 1d array contains
    three elements. So what do we mean by shape? So if we just say shape? What is that thing?
    So shape is 233. And let me tell you what that means. The return is tuple. So that's
    a tuple. That is returned to three and three. This two means how many two dimensional arrays
    are there? Here we have two. So in each two dimensional array, how many 1d arrays are
    there? Well, three in each one, the array? How many elements are there? Well, three.
    So basically, this C dot shape, zero, tells you the total number of two dimensional arrays,
    that is too. And this shape. For example. One tells you in each 2d array, how many 1d
    arrays are there, these many? And this shape, for example, to tells you in each one the
    array, how many elements are there? Well, three grade? That's awesome. Yeah. Can I tell
    you 111 screens kind of thing? You can you can define a NumPy array, for example, a as
    NP dot array with just one element, let's say two. That's an array raid. What's the
    number of dimensions here? What do you think? What is that? Is that a 1d array? What are
    the number of dimensions? Strange? It's a 1d array. Yeah, it is. see another thing?
    For example, b is equal to NP dot array. And you define it with let's say three. And what
    are the dimensions of B, it looks like the same, the dimension of B should be one as
    as their the dimension of A is one, it looks like the dimension of B is also one. No, it's
    zero. Because that's an array. If you pass it as as a list. It's an array of one D if
    you just define just one number that can be defined as an array NumPy allows you that
    but that one number is just as a yo D array. Now if you can get in it, a lot of zero days,
    you get one day if you concatenate the last one days, you get a duty. If you're getting
    a lot of duties, you get a 3d and so on. Get a look and feel Yeah. So that's what it is.
    So yes, In this video, I discuss the shape there is another There is there are so many
    properties, let me let me discuss some properties, let's size that actually tells the total number
    of elements complete total number of elements in the array. So, how many elements are there
    that is size. There is also I guess m bikes property, that tells the how many total number
    of bytes that the destructor is taking inside the memory. And there are several other I
    mean properties, if you just apply a tab and get certain things, you will see a lot of
    functions. And you can you can check a lot of properties that some of these functions
    we will explore later on. Sometimes they are called the universal functions, we will see
    them because they are very, very fast. And these functions the vectorized implementation
    of these functions. That is the reason why NumPy is so so fast, and why it is so popular.
    Anyways, so in the next video, we will go to explore the NumPy a bit more. And we'll
    show you more fun stuff with the NumPy. So hope to see you in the next video. NumPy actually
    provides a lot of functions to create arrays, special kinds of arrays just for testing.
    And sometimes just for. I mean, there are a lot of ways to create arrays from scratch,
    for example, what if you want to create an array containing all zeros, so there is a
    function in NumPy NP dot zeros that tells you how to do that. Similarly, if you want
    to generate a lot of generate an array containing a lot of ones or all ones, there is a function
    to do that and stuff like so, there are some functions that are actually used a lot and
    I want to discuss those. One function is NP dot arrange, actually, this is a single R,
    this is not a two Rs, this is single r NP dot arrangement, one R and NP dot arranged
    function, what it does is it creates an array for example, if you say NP dot arrange, it
    creates an array for example, if you say okay, 100. So it creates an array that it creates
    a 1d array that starts from the the values in that array starts from 012, all up to 99.
    So that's an array. That's a quick way to create an array with all the numbers till
    100. Yeah, so let's see, let's see running example of this NP arrange method in Jupyter
    Notebook just to get a better look and feel of how it works. So let's see. So let's say
    we have a equals NP dot arrange. And let's see 100. So that's it. If you want to see
    what is inside a, you can see this is an array with all the values starting from zero up
    to 99. Maybe you want to create an array that starts from a particular number ends at a
    particular number. Maybe those two numbers are different. And maybe this arrange function
    actually allows that. Let's say I want to start with 20. And I want to end at 100. And
    I want to create all the array that does that. So let's say this. So that's okay, start from
    20 and 100. But the last element last index is not included. That's possible. Last but
    not the least, if you want for example, to start from 20 and add 100. And let's say you
    want to take a jump of three. That's possible. Remember, does this does this resemble with
    something that you know already? Remember that? Yeah, let me pause for a minute, but
    not for a minute, just for some seconds. Let me pause. Do you remember this arrange NP
    dot brains function? It looks like something like what? Remember that for i in range? Yes.
    for i in range, for example, start from 20. Go 200. Take example three. Remember that?
    So it has some resemblance with range function? Yeah. Although range is an arbitrator.
    What's an arbitrator? why I'm telling you that? Okay, let me tell you an arbitrator
    as well here, just just just just spend a few seconds on on this range function. You,
    you might be thinking when we call this range, let's say starting from, let's say range them,
    you might be thinking that it returns a list of numbers, starting from zero to nine, but
    that doesn't happen. It returns nothing. Actually, when you actually call it when you actually
    call it it returns just an object. When you call it in a for loop or somewhere. It progressively
    do. rounds one by one element one by one. So it returns an element, then it hydrates
    and return another element that it never creates a list of elements, it now creates a list
    for you. That's awesome. Actually, it generates numbers, it generates the next number and
    the next number as you move on. So it saves a lot of memory and these kind of objects,
    they are called I craters that I played, they they never played. But if you want, for example,
    to get a list, if you really want to get a list, then what you can do is you can call
    the range, let's say in the same way, and you can just write a list. So provide me a
    list don't just provide me an ID. And that will give you a list. How cool is that? Right?
    Anyways, that was just a side note. It has nothing to do with this arrange function anyways.
    So NP dot arrange, it actually returns an array does not it is not like an iterator,
    it returns an array, complete array the way you want. So that's what this arrange is it
    has resemblance with this built in range function that mostly used in in for loops. Okay. Next,
    let's discuss this NP dot random dot permutation NP dot random is a package. And P is a package,
    it has a lot of sub packages inside random as a package. Random has a lot of modules
    one module is permutation. There are a lot of other modules. So let's see this random.
    Let's see what it does. So for example, let's say a equals NP dot random dot, permutation,
    let's say permutation. And what I do is I say okay, np dot arrange, let's see 10 what
    it does is, this NP dot arrange will return an array containing all the values zero to
    nine, these are 10 values, and then this permutation function that resides in the package and P
    dot random that is in the random packet of MP, it actually shuffles all the values and
    rearrange all the values in random fashion. And he will now be an array containing the
    same elements, but in a different order in a different random order. So let me know print
    this a, it will be having all the elements from zero to nine bought in a really shuffled
    away. And that shuffling is completely random. Yeah, you see that? Sometimes you may you
    may call some function, you may want to write some function on arrays. And you may want
    arrays that are that that do not have a particular ordering, there are just random arrays, just
    to test your code just to test how it works on any kind of array. In that case, one way
    of getting shuffled kind of array. One quick way is to just use NP dot random dot permutation
    function. The NP dot random package does not only have this permutation, there are a lot
    of other functions and be random, for example, np dot random random dot Rand int, for example,
    Rand int, that creates a random integer. That's, for example, if I that's that, let me call
    this and we have, how can it be used? Okay, you can give a low value from the very start,
    we can give a high value, I mean, and it creates actually, random integers starting from low
    ending at high. So that's how it can be used. For example, let me call it as NP dot random
    dot Rand int, create a random number between 20 and 30, create some random integer, and
    it will return some random integer between 20 and 30. If we call it again, it may return
    some other is it is returning 30 again, 29. Again, and again. Now two turns 2932. Maybe
    we want to maybe want to generate random integer between 20 and 30. So it creates a random
    integer. One thing that you might be noticing what is the what is the return value? the
    return value? Is we for example, what should be the type of E or do you think? Is this
    V is an array? No, it is a number. It's an integer, the type of VA should be an integer
    because it is returning a random integer it is returning an integer but it is selecting
    that integer randomly from 20 to 300. So it should be integer and it is Yes. Wow.
    Yeah,
    so we will be exploring some more functions in the random package of NP and then we will
    be moving towards this fascinating function score function called V shape. So there is
    more to come for NumPy so hope to see you in the next video. Okay in the last video
    we saw a range function that's a very useful function to just create a test testing array
    and just see see the output of a particular operation or algorithm, just on different
    kinds of arrays. Further we saw permutation functions permutation function in NP dot random
    package. And we saw that this this permutation function, actually, it reshuffles, it shuffles
    different kinds of odd if if array is applied to this permutation function, it actually
    shuffles all the, all the elements of that array in a random way in a completely random
    way. Today, we will explore this random package a bit more, and then we will see a reshape
    function, but that reshape does basically this reshape, for example, if you have an
    array, let's say, array, is let's say we have an array with, let's say, 10 elements, and
    if we call a dot reshape, and we give, let's say, two by five, so it will make a two dimensional
    array out of a, which is B, and that will be a two by five matrix R, that will be an
    array, or a matrix with two rows and five columns. And now we can, we can just work
    with this B, just like it's a two dimensional array, and we can just, we can just treat
    this B as a two dimensional array and work with that. It is it becomes handy sometimes
    if for example, we want to, we want to test certain operations on on matrices. A quick
    way to make a matrix is just to call arrange function, and then whatever the result is
    just reshape it into the desired order matrix and test the algorithm. So let's go to the
    let's go to Jupyter Notebook and check this random package a bit more and then see the
    reshape function. So let's go to Jupyter. notebook. Yes, so there are a lot of ways
    to generate these random numbers. One for example, we already have seen Rand int. And
    other way for example, array, an array can be generated, like MP dot random dot RAND
    function. So now, if we create this, if we create, let's if we pass let's say 1000, random
    value array will be generated in a and a each value of a will be a random number between
    between zero and one. So all these numbers are just random between zero and one each
    number is zero and one random number. And, and this distribution basically is the distribution
    of this random number is all the distribution is uniform. If for example, you want to plot
    the histogram, the histogram or the distribution of a it will look like uniform. Let me just
    give you give you one or two plots, using matplotlib package, although we will see matplotlib
    package later on. But let's assume that this is just a plotting package. This is just a
    package that helps us plotting just import that import mat plot lib.pi plot as PLT import
    that. And after importing that, you just plot a histogram PLT dot hist, for example, and
    pass a and you can see the histogram is roughly uniform. I mean, everything is equally likely
    we can make more bands, for example, we can have bands, equals let's say 100. And we can
    see almost all events they are I mean just look like uniform. If we make more and more
    data set, then they will all look uniform. One more thing we can we can have, for example
    this. And let's say B equals NP dot random dot Rand n, and that generates normal random
    numbers, or Gaussian random numbers, let's say which which the distribution of the numbers
    are is the bell shaped curve, for example, so let's just PLT dot haste B. And then let's
    say equal to 200. And we can see a bell shaped curve because the distribution of this data
    is is Gaussian distribution looks like so. So this this random packages, this NP dot
    random is really important package. It has different, it can create different kinds of
    random numbers from following from different distributions and doing in machine learning
    or in statistics, sometimes we need to generate these kinds of random numbers for sometimes
    for testing purposes, sometimes for adding noise of a particular type to test our model
    and stuff like so. So it's good to have a good grip on NP dot random package. Okay.
    Next we see reshape function. One more thing. For example, if you want to create, for example,
    a two dimensional array of just random numbers, let's say you can call NP NP dot random dot
    Rand. And you can just call a, you can just pass two arguments, for example, two by three,
    and the C will be a two by three matrix. If you see the C, it will be a two by three matrix
    of four random values. If you see c dot, and then it will be having the dimensions are
    two. And it's a two dimensional array. Further, we can create, for example, a four dimensional
    array c equals NP dot random dot Rand, maybe two by three by four by two. And that's a
    four dimensional array with this particular order. So if you see this C dot m, then that
    will be level b, this. Yeah, so let me let me just give you an interpretation of what
    that thing is. There are two arrays that are three dimensional. And there are two of those.
    Okay? Now, each three dimensional array has three two dimensional arrays. Wow.
    So each
    two dimensional array has four one dimensional arrays, and each one dimensional array has
    two elements in it. So that's what the structure is. Yeah, get a good look and feel. So let's
    see the reshape function. For example, let's say we have d equals NP dot range. Let's say
    we have 100 values. And then we say reshape these 100 values to let's say, let's say four
    by 25. So this D will be a four by 25 matrix. So if we just get the shape of D, so that
    will be a four by 25 matrix or a two dimensional array with four rows and 25 columns. Yeah,
    so sometimes we want to work on matrices, and we just, we can just plug in these arrays
    function to generate a bunch of numbers. And then we can reshape those and build a matrix
    quickly, and then just test the performance of our algorithm or stuff like so. So, not
    only the reship not only returns the, the I mean, you can you can reshape a matrix,
    and you can reshape an array into more than two dimensional array if you want to, for
    example, arrange 100, let's say dot reshape, maybe or as four by five by five, it's a three
    dimensional array. Now, this D will be a three dimensional array containing different values.
    Yeah, so now you can access it and do whatever you want to do. So not only the reshape, arrange
    and permit random, there are other functions as well NP dot zeros. For example, if you
    press z, and you just see the zeros, and then you just press the question mark, you will
    know what that function is how can we use it and so on. Similarly, you can have several
    other function there is an important function once for example, you can call that function,
    and that will generate an array of all ones, you can see how to call that function here.
    There is NP dot empty, there is NP dot empty, like there are so many functions just to create
    some matrices very quickly. And you want to test your core algorithms based on those.
    So yeah, so there are a lot of functions that we want to that we can work on. So next, so
    there are a lot of functions that can quickly create a NP array and an n dimensional array.
    That we can quickly create an array test or algorithm or use the array wherever we want
    to like we're everyone to use. And we can move on just a few functions like arranged
    ones zeros, they are there are random dot Rand random dot Rand n, and other functions
    they are available. For In the next video we will be seeing we will be seeing the indexing
    or slicing inside NumPy array and we will also be seeing the difference of that indexing
    with or slicing from the array In the list or or are the ordinary data structures? What
    is the difference in? What is the difference of slicing in NumPy? with for example, with
    the list, we will see that in the in the next video, hope to see you in the next video.
    Okay?
    Here is my favorite topic in NumPy slicing. Actually, indexing or slicing in NumPy is
    the way you access sub arrays is just the same as the way you access sub strings or
    sub lists. And you already have seen, how can we how can we use the slicing or indexing
    in lists and in strings, the difference here in NumPy is in list for example, if you slice
    you get, for example, let's say B equals a one colon five, if you slice that thing, from
    NumPy, then B is not a copy, it is actually accessing the same memory view as an A. Now,
    if you change any element in B, the corresponding element in a will change as long as as a NumPy
    array. However, if A is a list or any other data structure, ordinary data structure, then
    the slicing this, this kind of slice gives a copy rather than a view. So that's an important
    difference, we need to know that rest of the indexing technique is almost the same. You
    do this kind of indexing that is how you can reverse this a start and step all all the
    things are same, except How can play How can we play with the two dimensional arrays. Let's
    let let's see that. Let's see some examples of indexing one by one in in Jupyter Notebook
    and see how the slicing actually creates a view rather than a copy. So let's go to our
    Jupyter Notebook and see how can we play with different indices, let's say a is NP dot arrange,
    and B dot arranged, let's say 100. And let's shuffle them. Let's say as it is, let's say
    that's a now a, let's say, let's bring some certain things. Let's A B equals a big all
    the elements starting from index three, ending at index nine, Sudan is not included. That's
    B, that's blank v. Let's see what's B. So b is this array. Okay? Now what I'm going
    to do is I'm just changing the contents of b, this NumPy array is mutable, you can change
    the elements inside, no problem. So I'm going to change the elements, let's say one element
    in B, let's say, I'm going to change element numbers zero, and B, which is three, and I'm
    just placing that element as minus 100 minus 1200. That's it. That's the case. Okay, now
    the contents of B has been changed. We are but now let's see the contents of a the contents
    of a also has changed. That's a big difference between slicing an ordinary Lester adini data
    structure or slicing a list, when you slice a list, you get us you get another label,
    but that label or that variable is accessing the same memory, the memory actually is not
    copied. There is one memory view. And these two different names, whether you access those
    elements using B, or you access those elements using a the same memory is being accessed
    if you change the memory using B or A you will see the effect in both of the variables.
    So that's one difference. Now, after having knowledge of this difference, if we really
    want this behavior to not happen, one thing that we can call is we can say okay, a, for
    example, a, let's say three to 10. And then we can call our famous function, remember
    that copy, you can copy that and now B is completely a different array. It's it's a
    different memory view, if you change B now, the effect will not be seen in a so copy function
    is there whenever you need copy. One thing if you are not going to change elements the
    number is applies you very fast implementation of slicing by not changing the memory view
    if if you are aware, your algorithm is not going to change the elements slicing will
    give you much much efficient access to the elements or the or the sub blocks or sub arrays
    without actually making the copies inside the memory which can take time and space both.
    So this is one plus of NumPy Over the over the other data structure that we have seen
    so far in Python, okay, let's play with indices,
    let's say what do you think? What is that thing? colon, colon to what? Or colon colon,
    let's say five, what it will do, it will start from the very first index, which is zero,
    it will go to the last index, but it will pick every fifth element. So let's see. So,
    it picks zero then five then 10, then 15, because the jump is five break, what do you
    think what this will do? Let me just let me just teach you by example, what this will
    do. Yeah, what it will do remember, if you apply a minus here, the end and the start
    and end they just get swept, and this becomes a step from from the end. So, what will happen
    is the same kind of impact, you start from the very end, then you take the step of minus
    one from the end, and you just based every element, so this is kind reversing the array
    with with kind of step starting at the end rate. So, another way of reversing the array
    is if you want to reverse the array as a whole display minus one, which means start from
    the end and pick every element from the end till the beginning and the end, and the array
    will be reversed. This element is there, remember that this is there, let's chain that element.
    Let's chain that element. So, so a adds position. So, I want to find out the index, where this
    minus 1200 is located. So Id x is equal to a dot index I guess there is a function index
    Yes, he has a no index Oh, there is no index there. Is there an MP dot index and P dot
    index? I want to find out the index where so in DAX there is no index function indices
    or something, I want an index function is there any index function I want to find out
    the index? Where minus 200 is located? There are several ways but I want to find one. So
    for example, for example, let me see whether there is an index function and not available
    in NumPy or not. No, it is no longer there. But there is in the CS function, I guess.
    So in the CS, what that does, I guess that does the same job. Let me see MPR indices
    returns an array representing the indices of a grid, okay. So I have to give a grid
    and then it returns for example, the indices of all that grid, how can I use that? Well,
    it becomes it becomes difficult, there may be a find function, or how can you locate
    the index where the minus 200? Is, is located? How can I How can I do that?
    Huh?
    Yeah, very difficult. Seems like very difficult. Oh, why don't I rather than finding out a
    function? Why don't I just play with play with the NumPy? Why not? So let's say a equal
    equals minus 1200. That gives me a Boolean array comparing each and every element with
    minus 1200. So, the array the returning array, let me call the index array or the Boolean
    array, let's be that array is true or false array or zero or one array, wherever there
    is minus 1200, that index is one that value is one otherwise it is zero, completely zero.
    And then what I do is, I just multiply that with with NP dot arrange NP dot arrange with
    with saying that a dot A dot A dot size, so whatever the size of A is, so because these
    are the indices Okay, then what that's point wise multiplication grade. So, when I will
    multiply them together, what I will get is is what I will get from multiplication, I
    will get, how can I How can I find out actually, a train lost here literally, how can I find
    out how can I find out the index where Where am I? So that will give me what? Let's see,
    what is B. Now, the B is B is just an array. B is just an array, and there is this three.
    That is looking at it. So how can I find out? Where is this three? How can I, again, the
    problem is finding out the index. Okay, that's, that's really a bad thing. Can I call this
    aid dot indices? And just give a minus 1200. And everything just worked out? No, there
    is an error, there is an error. Oh, I'm lost here. Literally, I'm lost here, I need to
    know how to find out the index where this particular element minus 1200 lies. So
    that's a
    question for you as well. I'm also lost. So let's see you in the next video. And we first
    will solve this problem to finding out the index of a particular element, or maybe a
    lot of elements. And then we will continue from there onwards to see more indexing. Okay,
    great. So hope to see you in the next video by first solving the problem, how to find
    out the index of a particular element in a NumPy array, or maybe more than one elements
    in a NumPy array. And then we will be practicing more about these slicing examples. Okay, hope
    to see you in the next video. Okay, let's say this element is there. And let's say we
    want to, we want to locate that element in the array, we want to just know where this
    element is in the array. So array has this element. Let's let me paint array as it is,
    this array has this particular element, and we want to know where what is the index of
    this element inside the array, there are several ways of doing this. One way is to find out
    their index is simply you call the function arc where arc where for example, org, where
    A is equal to minus 1200. And that will return a 2d array. And if you just want any one index,
    then you return that kind of thing. So if you write this thing, you will get the index
    exactly of the element that is there. So the index is three, if you want to change that
    value, for example, the value should be three here, if you want to change that value, what
    you can do is you can right, okay, ie x is equal to three, and is reverse to its position
    wherever it was created, okay, great. Now, let's play with the two dimensional indices.
    Let's do dimensional arrays, let's say we have a equals NP dot random dot, Rand, let's
    say, let's say we have a five by four matrix, let's say a two dimensional array, let's round
    all the values by multiplying them to 10. What it does is because all the values this
    RAND function, all the values it generates are the values between zero and one, what
    this multiplied by 10, what it does is, it actually scales up all the values to 10. And
    then round function, actually, round downs are actually rounds the values to the integers.
    Now a will be worse the problem round that third round method is no longer there. Okay,
    maybe there is NP naught round, maybe that NP dot round, maybe NP dot round is their
    Yes, and B dot round. So round function of NP. So this a is a is this array, for example,
    that's five by four, a four, five rows and four columns. So let's say I want to access
    the second row. First of all, let's say I want to access this particular entry. This
    particular entry is second row and third column, which means the index is one comma two, because
    second row means the row row first has index zero. row two has index one. Similarly, column
    one has index zero, column two has index two, a one and column three has index two. So that
    is what this particular entry is. What if we want to access the whole second row, for
    example, we want the second row. So that's how you call that's how you slice. A normal
    meaning of this is you the role should be one and the columns, all the columns, so That's
    how you access the whole second row. If you want to, for example, access the whole third
    row, for example, or a whole second column, let's say that means you say this, okay, the
    column number second, and all the rows, which means the whole second column that is accessed.
    That if you see, that's the whole second column six, four to 10. And one, that's what the
    second column is. Further, once you have a, you can, you can, for example, access a sub
    matrix, let's say you want, you want row number one to rule number three, not including three.
    And then of these rows, you want column number two to column number
    four, let's say. And if you do that, you access the whole sub matrix. First, it actually picks
    row number two and row number three, because row number two starts from one. And then of
    those rows, it picks these columns, and you can just pick the pick the sub matrix inside
    more, you can, you can do a lot of processing on these matrices. For example, this is matrix
    A, if you just type a dot transpose, that these four transpose, the matrix just is taken
    transpose of it. Further, there is a complete library, linear algebra library in NumPy.
    For example, if you just import NumPy NumPy dot linear algebra, as a for example, then
    this linear algebra library in NumPy, has a lot of functions, Eigen values, chelski
    decomposition, computing determinant of a matrix, finding out inverse of a matrix and
    what not. For example, let's say we have la dot inverse, and here is NP dot random dot
    Rand, let's say, some three by three matrix. So what it returns is, it returns the inverse
    of this matrix, and this linear algebra library, and there are other libraries as well. But
    this is one scientific library, that may be most of data science experts who actually
    want to do research, they might be thinking, this linear algebra library, that that specifies
    a lot of functions related to related to these matrices or two dimensional arrays. So that
    is there. Okay, so that's about indexing. We can play with these indices a lot if we
    want. One more thing, just just one. One last thing, let's say this is our a. And what we
    want to do is let's say we want to sort this A with respect to the columns, we want each
    column to be sorted individually, what we can do is we can call sort function, and we
    can pause X's equals zero, access equals zero, that means sort all the columns individually
    and the result will be if you see the result, the result will be every column is sorted
    individually. If we want to sort for example, every row individually, we will say okay,
    sort x is equals one, and every row will be sorted individually. And if this is a multi
    dimensional array more than three more than two dimensions, then x is can be two x's can
    be free. So which with respect to whatever axes you want, your sorting can happen. It
    can do that, if A is one dimensionally, then dot sort function without an access, just
    sorts just sorts the one dimensional array from beginning to the end. And if you want
    to descending order a sword just sought them sorted first and then reverse it using indexing.
    Great, I mean, there is a lot to discuss, there is a lot to discuss, I'm ending this
    slicing here. In the next video, I'm going to show you kind of masking or sometimes called
    the fancy indexing that is much more powerful and useful in a lot of different contexts.
    So hope to see you in the next video with more NumPy indexing. Okay, there is another
    way of indexing a NumPy array. In the last video we saw we can, we can do slicing notation,
    for example, start from here and here and stuff like so. There is another way of accessing
    a NumPy array as we have an array and we can just give the give an index array inside for
    example. Let's say a is one dimensional array and then we just give 146 that means big element
    at index one, pick the element at index four, pick the element at index six. So this kind
    of array inside can be a list or an array. That is called an index array. And you can
    just pick the elements that you want to pick, for example, you want to pick all all elements,
    you want to pick first element, fifth element and 17th element, you can just create an index
    array and pass it. And in an index your and access your elements using that index array
    that's possible in NumPy array. Further, you can access different elements using a Boolean
    mask as well. So Boolean array, for example, true, true, false false, wherever there is
    a true pick that element wherever there is a false, don't pick that element and return
    the elements that are picked. For example, assuming here that you have an array, which
    is one dimensional array, let's say, assume that has eight elements, 12345678 elements.
    Now you pass a Boolean mask inside, where with with obviously, eight elements, a true
    or false values, wherever there is true. So pick the very first value, pick the second
    value, pick the don't pick the third value, don't pick the fourth value, pick the fifth
    value, pick the sixth value, pick the seventh value, and don't pick the last value. So that
    is also possible in in NumPy. One thing that is important is if you do this kind of indexing,
    which is sometimes called masking, if you do that, if you do if you supply an array
    index, or index in a Boolean form, you by default get a copy as as as compared to slicing
    in slicing, you get a view that's a separate copy, you need not to call a dot copy function,
    it is by default, a different copy. And this is a difference between the ordinary slicing
    that you do, for example, start from one go till 50, take a jump of let's say two, if
    that is your indexing style, that is called a slicing, the return value is a different
    view having the same memory. However, if you do the, if you use the array index, or the
    Boolean array called masks, then you get a copy of rather than also so which means if
    you if you get a new array, you change the elements in the new array using the array
    indices. You're not getting that change happen to the original array. So that's the difference
    between slicing and masking. Okay, this kind of Boolean indexing becomes really handy.
    For example, what if you want to exit? What if you want to get all elements that are smaller
    than eight, one way to do that is just write a and then apply a condition is less than
    eight, well, a is less than eight, we'll create a Boolean array. And everywhere where the
    element is smaller than eight, there will be a true otherwise it will be false. Now,
    the inside array is a Boolean array, and you access all the elements with respect to that
    condition. So it will return all elements that are smaller than eight. How how fancy
    is that? Further, you can you can have these conditions in a combined way. There is one
    difference there is an AND operator A and D and, and there isn't an operating in a different
    way. So I'm going to discuss the difference of this and this and as well in this in this
    whole in this video. So let's go to Jupyter Notebook our fan and see how can we play with
    this masks.
    So let's say a is again and B dot arrange, arrange, let's say 100. That's it. That's
    our a. And what we now do is we access the elements of A, B access, for example, the
    third element and the fifth element and the sixth element. Let's say we want to do that.
    And that's our B. So that happens, let's say, so what B is B is this, something that you
    need to know is if you change the elements of B now, because that's a copy, let's say
    minus four, that change does not happen in eight that happens in B for sure. But that
    doesn't happen in a, a does not contain any value that is minus four. Because using these
    kinds of indices, the array index By default, the result is a copy rather than a view. Further,
    let's say you have this a and you want to access all the elements that are smaller than
    let's say that are smaller than let's say 40, access all elements that are smaller than
    40. So that is possible now even contain only the elements that are smaller than 40. All
    the elements while further if you want to access all elements that are that are smaller
    than 40 that are smaller than 40. And they are bigger than they are smaller than 40.
    And they are bigger than 30. Let's say you want to access all the elements that are between
    30 and 40. You can just access those elements like so there is a problem. A dot any a dot
    all what's the problem here? The truth value of an array with more than one element is
    ambiguous use a.ne or a dot all. Okay, this a is less than 40 is a Boolean array is greater
    than 40. That's a Boolean array. So what's the problem? What, why can't we not use this?
    What's the problem? We should have used that. So use and, and, yeah, I guess we were missing
    these, we were missing these brackets because it might be confusing this 40 with this a
    and stuff like so. So use parenthesis rate. Now, B contains only the elements that are
    between 30 and 40. Now, one thing, what's the difference between this particular and
    and this symbol and the difference is this and AMD an operator It is used when both of
    the sides of this end has what is one object and it has one true value either true or false.
    And this particular symbol is used when the left side and the right side can be arrays,
    and each element of that array can be true or false. And so, so, you can think of this
    and is using arrays, however, this is used when both the sides are single objects. So
    that's the difference. Other variants of and I mean, the end is like this, that these are
    these are the same things, but remember the use this is used for arrays, this is used
    for single objects. Similarly, there are other symbols like
    or
    that is used this way or or that is used that way. Similarly, there is a not not for arrays
    is used like this way and not for otherwise, is used like that way. So remember these the
    left side, I have symbols, they are used for arrays, the right kind of symbols, they are
    used for single objects that has true or false values. So these, this kind of masking is
    really, really powerful. Later, we will see in pandas accessing different kinds of data
    with particular kind of conditioning, that becomes really handy if we if we are comfortable
    with these kinds of indexing. And that's really powerful indexing. Okay. So, I've told you
    the difference here between Aaron and I've told you that this is copy rather than a view.
    So just bear with me some more time on NumPy. And I will tell you some more truths about
    NumPy. And then we will move towards another package called pandas. So before pandas more
    NumPy is coming, I hope to see you in the next video. Okay, in the last video, we saw
    masking, which is sometimes called the fancy indexing as well. And here we are going to
    discuss one more feature of NumPy, which is very powerful feature called broadcasting.
    I think, for example, you have an array, let's say two, three, a matrix, that's a two dimensional
    array 235 and nine, and you want to add, in every element, you want to add a number, let's
    say five. So one way to do that is create another array with 5555. And just apply this
    add operator and you are done. Great. But this NumPy allows you to just write let's
    say this is array, a NumPy allows you to just do this particular thing. And this five is
    automatically broadcasted to match with the dimensions of its other operand. And addition
    happens you need not to do this explicitly. And this broadcasting is not just one scalar
    value. For example, if you have one variable, let's say a is this and you want to add, for
    example, this particular column, let's say one three, you want to add this particular
    column in the first column as well as in the second column, but then you need this one
    three to be copied again and make a bigger array and then you do that well, broadcasting
    allows you if you just write this as a plus one three, it will be automatically broadcasted
    to match the size of the other operand, wherever the book broadcasting is possible, there are
    certain rules to to know when broadcasting is possible it is not possible each and every
    time. For example, if you have this matrix 239 and Jeff 421 Let's at this matrix and
    you want for example, two one and six two, for example, if you want to do that, the broadcasting
    may not happen because in this way, if I want to broadcast this structure, the structures
    should be if if the structure is broadcasted to in horizontal way, the the two columns
    will be arrayed and the addition cannot happen. If it expands to a vertical way still the
    addition cannot happen. So, this here you will get an error because broadcasting is
    cannot happen, but in several cases when you want to add for example, a scalar multiply
    with a particular thing wherever possible this broadcasting is possible and broadcasting
    is just a I mean it just a feature of NumPy that allows you to not repeat to match the
    dimension of the other operand to apply a particular operator it does it by itself great.
    Next, we see some more important functions to no one is horizontal stack. That means,
    if you want to concatenate two different array two arrays that are that can be concatenated
    together horizontally, you can get out you can call at stack function and that will concatenate
    the two arrays together and returns another array. Similarly, V stack is if you want to
    concatenate two arrays vertically, if they can be concatenated vertically, vertically,
    similarly, there, there is another powerful function sort, and there are a lot of other
    functions, these kinds of functions, they are called Universal functions. And they are
    very, very, very powerful, very, very fast their implementation is vectorized, where
    Christ mean the implementation the all loop kind of layer is deferred to at the compile
    time and the things are really faster when you do a vectorized code. So, having said
    that, it is always recommended to not use explicitly for loops to achieve these kind
    of,
    to achieve these kind of results, whenever a universal function is available, use that
    because the efficiency of that universal function will be way, way way more than then whatever
    loop loop or whatever function you will be writing other than the universal function.
    So, and by the way, there is another function concatenate as well, in which you can specify
    axes. And it will either act as horizontal stack or either act as vertical stack, depending
    upon whether the x value is zero or one, whatever. So, let's just get comfortable with these,
    these three functions, just quickly neural Jupyter Notebook and see an example of, let's
    say, broadcasting as well. So let's say we have a function, and let's say you have an
    array is let's say, np dot random dot Rand, let's say that is two by three. And then I
    just multiply this with them. Remember the last thing and then we just NP dot around,
    we just round everything. So that it becomes it becomes whole, in this particular way.
    Okay, that's a, let's say, so that's our a, that's the now if we say a plus three, three
    will be added everywhere in a, and that happens through broadcasting. Well, if we if we do,
    for example, a plus, for example, np dot range, let's say just do values, and then we just
    reshape it, reshape it, to reshape it to let's say, a two by one matrix. If you do that,
    then still, what what will happen is just apply the parenthesis just to show that this
    should happen. First, what what will happen is there will, there will be a column that
    will be added to every column A, and that again, will be happened through through the
    broadcasting. So broadcasting is that powerful. Next, let's see the stats. So that's it, this
    is a, let's say we have the that's another way, let's say NP dot random dot Rand. Let's
    say that new array is two by two. And again, let's say it is multiplied by Dan and NP doc
    round just to avoid the decimal points. That's it, this is B. Now a is two by three array
    D is a two by two array, if I just concatenate them horizontally, I will get another array
    which will be two by five. So C equals np.at stack horizontal stack, at stack, and I will
    call these A and B. One thing that you need to know is if you if you want to call this
    x stack, horizontal stack or vertical stack, these arguments in B that you want to concatenate
    you have to give them in a topple or you may you may want to give several values to concatenate
    together maybe you have maybe you have 10 matrices to concatenate together horizontally.
    You have to give all these as a tuple inside a All right. Now similarly, we can do a vertical
    stack if we want. I mean, one on top of the other. And we can call it and getting it function
    as well, if you want. Third is sort function. For example, if we want. If you want to use
    NP dot, let's say a is NP dot random dot permutation, let's say NP dot range, let's say the 10 values.
    Let's say that our a, let's say, this is a, and we want to sort this array. Oh, this is
    already sorted. Why is it sorted? No, it is not sorted 1/4. It is not sorted? Yeah. Let's
    say we want to sort it a dot sort. One way of doing that is just call a dot sort, and
    you're done. That's the value of a another way, which is sometimes more readable, although
    exactly the same is to use a universal function, using NP dot that thing that also is the same
    thing. Now sort by default sorts in ascending order. If you want to sort in descending order,
    then what you can do is you can sort aid or sought, for example, do that in ascending
    order, then what you do is you just reverse it, minus one, and just copy that in a again,
    now he will be sorted. While sorted in descending order. Yeah, great. Um, one more just just
    just just to give you one more flavor, if you create an array, for example, np dot array
    of strings, for example, ABC, and another string is, how are you and vai maybe we have
    another string? Whew, 785. And maybe we have another string, one, three e r, that's it.
    That's a string. That is possible. As long as all the objects have same type, you can
    create an empty array. Now, you might be wondering, what we'll do this sort function on a because
    these are all strings? Well, the answer is it will sort the strings according to the
    alphabetic order, whatever the alphabetic order is, whatever string according to the
    alphabetic order should become first that will become first and the other strings, they
    will they will just join. Yeah. So yeah, so that's about something that is not that is
    not the numeric value. Okay, great. There is a few more things to come about NumPy array,
    and then we will be moving towards panda's library that is built on top of NumPy array
    for better processing of data, I hope to see you in the next video. Okay, in last video,
    we saw horizontal concatenation, vertical concatenation sort function, we also saw some
    broadcasting and stuff like so. Universal functions, it should be speed here, sorry,
    it should be speed, speed. Universal functions are really, really speedy, I always am talking
    about NumPy. Whenever I start NumPy, I said, it is fast, it is fast as fast, I never show
    you how fast that is. So let me give you an example. Let me let me just create an A NumPy
    array with a lot of numbers, and then just apply an ordinary function, let's say want
    to add all the numbers in this array B, let's apply an ordinary function that is not in
    NumPy. And then let's use universal function dot sum, and see how speed differences there.
    If for example, we apply apply a universal function to achieve a particular task how
    speedy that universal function is, because a vectorized implementation, as I told you
    is much faster, how faster let's check that out in new Jupyter Notebook. That's a magic
    command time ID that will tell us how much time this particular task has, has taken.
    And if you run this command, it will it will call this function again and again several
    times. And then we'll report an average value that will be much more stable than just calling
    once. After that, we will also we will also write our own sum function using loop. And
    we will see whether that is even closer to a universal function speed or not. Let us
    just check the speed of universal functions that will give you a look and feel of how
    much NumPy implementation is faster. So let's say we have an array, let's say B and B dot
    random dot Rand. And let's say that array is huge, really huge. Let's say that's the
    case. Now what we do is we let's say we we call a function sum. So let's say we call
    a function sum. That's a built in function. In Mumbai, that's a built in function that's
    a built in function in Python, not a NumPy function. And then let's say we do the same
    task using NumPy universal function and P dot sum, that's the same as NP dot sum is
    the same as if we if we write, for example, b dot sum.
    So whether you write b dot sum, or you use NP dot sum and be passed and passed, as an
    argument, both these things are roughly the same. So let's run it, it will take a while
    It will take a time because, okay, the sum function takes 307 milliseconds, that is not
    a universal function in NumPy. That's a Python function. That is not written in NumPy. That
    is not a vectorized code, nothing. It takes 307 milliseconds to perform to take the sum
    of the elements of this array. And it does that by applying seven rounds in in Santa
    loops. However, the universal function takes just around three milliseconds, I'm assuming
    2.7 milliseconds, how will how are you going to compare this 307? With three? How much
    faster you are around? Around 100? times your faster? I mean, yeah, I mean, this NumPy is
    literally faster NumPy, the universal function will faster, maybe you attempt to know that,
    okay, the sum function might be too slow. Let me write my own function. To do that,
    let me define my son, and my son just take an argument, let's say something, let's say
    G. And what it does is for, let's say s equals zero, what it does is for x in g, s plus equals
    2x X plus equals to x and then just return as nothing. That's your function. Let's say
    you think that this is really a great function. Let's do that. Okay, let's compute the time
    for this time it my son. And let's pause the rabee and see how faster this is. This is
    roughly the same as your calling the sum function, but this NP dot sum or the universal function
    is very faster, fairly faster. So, use universal functions, avoid for loops, avoid your own
    functions, if the same task has been a can be achieved through universal functions, whenever
    possible, avoid loops when you are working with NumPy. That serious suggestion, follow
    that, because the universal function written in NumPy, they follow the vectorized code,
    all the interpreted slowness that is deferred to the compilation layer. And the NumPy becomes
    really really faster and shows its power when you are working on large arrays using the
    universal functions. So I can speak more about NumPy. But I have told you some basics of
    NumPy. And we end the NumPy here and from the next video, we will be moving towards
    a very, very fancy and beautiful kind of package called pandas to handle data. And by the way,
    the pandas library the pandas package completely is built on top of NumPy. Everything that
    is there in pandas is built inside is built on top of NumPy as all the indexing and all
    kinds of stuff, slicing and speed. All is there in pandas that is due to the NumPy.
    So we will see one more package after pandas which is matplotlib for for plotting afterwards.
    And we'll do a project at the end using scikit learn as well, just to wrap up all these things
    together. But for now I'm ending NumPy here and in the next video, we will start pandas
    hope to see you in the next video. Okay, welcome to pandas data science package that is very,
    very powerful of handling data, manipulating data and used a lot in data munging and data
    cleaning and data pre processing and whatnot. This pandas basically is built on top of NumPy.
    So most of the features of NumPy is also available in pandas.
    Let's let's dive in. I mean, this pandas is a very, very fancy library, very, very fancy
    package, that you can handle very large amounts of data in CSV files or an Excel files. Wherever
    the data is located. The missing entries are there. You can handle all the data you can
    manipulate all the data you can prepare all the data in just a few lines of Using this
    pandas package, so let's just start pandas package. There are two most important objects
    of pandas. One is series and other is data frame that we will see later on, there is
    one more index. But the most important one is, or the useful one is the series and data
    frames. So let's just define, first of all, you need to import pandas package import pandas.
    And you can rename this as PD, that's a, that's the most popular renaming, although you can
    rename it any. And then you just say okay, PD dot series, and then just like a NumPy
    array, you pass the data that you want. And you can create your own indices, for example,
    like, just like dictionary, this a is a key value. This is a key or index for this point,
    two, five, this B is index 4.5, C is index 4.75. And these index four one, so you can
    you can, you can supply your explicit indices as well. If you do not supply the indices,
    the default indices are 012, and three, but you can define your own his own indices in
    the way you want. Now, once this data object is created, you can call the data values and
    you will find out the values you can call the dollar index and you will find out the
    indices let's see in the Jupyter Notebook just to get comfortable with pandas. First
    of all, import pandas as PD, maybe or something else. So okay, let's import it, maybe we can
    check what we're going to reveal working in PD dot worryin. The version of pandas we are
    working in right now is 0.2 4.25. Read. So let's create data or whatever variable let's
    say a as PD dot series buzy dot series and there we just give a list of some values 2345
    let's say these are the values. And then we can give index as another list. Let's say
    the indices are a maybe the indices need not to be strings, anymore, anything AB, C, and
    let's say the index of fighters. Let's see. So now the series object or the pandas object
    series is created. Series basically handles one dimensional arrays, later on, we will
    see DataFrame handles multi dimensional arrays, I mean more than one dimensions. Normally
    typically two dimensional arrays, but okay, a dot values. So let's call the values, values,
    and you will get all the values inside the series. And by the way, this values array
    that you get, let's check what's the type of that array was type of battery? A dot values?
    What is that thing? That's a NumPy array. Wow. And what's the type of a itself that
    will be a pandas object. Great. So everything inside pandas, the NumPy is playing all the
    role inside pandas. Great. So now, let's check the index a dot index. That's also a NumPy.
    That's also an array of index type, that's a different actually index is also an object
    in pandas. That's an index type object with these kind of indices, we can access for example,
    this a, just like we are working with dictionary for example, a dat returns a value, we can
    change the values, we can add different, we can add more key value pairs. So just think
    like these.
    Just think this data I'll just like the dictionary object that we saw this, these are the keys
    and these are the values. And this is one one very good way of remembering what the
    series does, and manipulating series The way we want. Okay, one, we can access a z like
    this, we also can do slicing. Let's say we want to access from A to let's say C let's
    say we want to access all these one difference is when you access like this, in the normal
    slicing using implicit indices, for example 123 or zero, the final index is not included,
    but if you access like so, using explicit indices that are there, the final index is
    also included. So that is one more fancy way of indexing using in this pandas. Okay. Great,
    that's a serious object by the way, we can create a serious object by first creating
    a dictionary for example. Let's let's go back to our slides and see this example, let's
    create a dictionary. For example, of plates, let's have a lot of students with Grade A
    grade A minus Grade B, red b minus, and let's create that dictionary, then we can just create
    a series object or panda's object, by just passing this dictionary inside, we can make
    another dictionary for example, and we can make another series object. So a one way of
    defining the series object is just to is just to pass the data as well as index in other
    ways to just first create the dictionary and just pass the dictionary variable inside,
    and the series object will be created. Okay, that was just an introduction to series, we
    will move on and see more features of pandas, as we as we explore it more and more in the
    upcoming videos. Hope to see you in the next video. Okay, let's say we have two different
    dictionaries, let's say we have a lot of students and the a grade is defined to be four and
    a minus grades defined to be 3.5. The b grade A has a number three, the B minus grade has
    a number of a numeric value that is 2.5. And similarly b grade has an American value let's
    do and then we create just a series object using this dictionary, let's say rather than
    just the numeric values as GPS or something like so let's say a grade also is defined
    at 85 marks in total, a minus graders defined at 80 marks in total, and similarly these
    and then we create another series object, let's say named with Mark marks using these
    PD dot series. So let's go to Jupyter Notebook and just play a little with these dictionaries.
    And build the series object, let's say marks, or let's say grades. dictionary equals, let's
    say, a grade, is has has an eighth grade has number value for RGB value for let's say,
    let's say we have a b grade with GPA value, let's say B is let's say it's 3.5. Let's say
    we have C grade with GPA value, let's say three. And let's say Finally, we have d grade
    with GPA value, let's say 2.5. Let's say that's a dictionary. Okay? What we do now is we create
    a grades series object, let's say using PD dot series, and just pass this grades underscore
    teched. Now this capital a capital B, capital C and capital D, they will act as indices
    and this for 3.53. In 2.5, they will act like values. So for example, if we call her and
    just now called grades dot v dot values, so we will get, for example, what is that? That
    just values, let's say, beget this grade stock values, and we get all the values that are
    available. Similarly, if we find grades or index, we will find out A, B, C and D. Let's
    define another dictionary, for example, marks dictionary dict. And there is let's say again,
    a while the total marks are 85. For the a grade, let's say, for b grade, the total marks
    are let's say, 75. Let's say for C grade, the total marks are
    let's say 65. And for D grade, let's say the total marks are 55, let's say. So let's say
    that's another dictionary. Now, let's create a series of objects, a series object PD dot
    series, series, let's say marks dictionary. So now again, we have if you just write this
    marks, just like so, you will see the marks is 85, b 75, c 65, D is 55. And all the values
    they are integer 64. Ghana values, now we can access. Now we can play with this marks,
    for example, if we just want to access for example, what are the marks? What are the
    marks between, let's say, for example, what are the marks given a at a we can access that
    we can change that we can just play like a dictionary. What if we rather than using the
    index In a, we use for example, slicing, we want to start from the very beginning. And
    let's say we want to go to two what will happen? Let's see. Yeah, so, the slicing is there
    for example, if you want these are explicit indices A B, C, D, these are explicit indices
    and they are there. For example, if you can slice the you can slice the data using explicit
    indices that you are given that you are given or implicit indices that are the default indices,
    the first value index at zero, the second value is index two one and so on. So, you
    can do that as well, one catch here for example, that we will see later on, there may be a
    problem that your explicit indices they are also numeric, and then you do the slicing
    like so, then the series object may be confused whether I have to use the explicit indices
    or implicit indices inside we will see how to resolve that issue, but by this pandas
    allowed to use explicit indices as well as the implicit indices. Okay, we were here.
    So, he just so, yeah, so, we were here. So, we have created these grades a series object
    This marks as a series object, these the series object is good for one dimensional arrays
    or data with just one dimensional list or dictionary, kind of with just one dimensions,
    later, we will see data frame that actually is is actually the extension of curl can be
    looks like it can be looked like as an extension of series towards more than one dimension,
    we may have, for example, two dimensional arrays or two dimensional data structures,
    something like so. And we will be seeing this data frame which is much more powerful, particularly
    for reading data from files and manipulating it and stuff like so. We will see that in
    the next video data frame that running form of data frame in the next video, hope to see
    you in the next video. Okay, in the last video, we were discussing series, and I told you
    that data frame is basically if if the data has if the data in the form of different columns,
    for example, a record as an array, then you have another record, then you have another
    record. And each element in that record is a different attribute. So this particular
    way of two dimensional data is very well handled using data frame inside pandas rather than
    series. So but you can make these data frame objects using different series objects. For
    example, you have a great object that grades object that we created last time, you know,
    marks object that we created last time, let's build a data frame using these two and see
    what it looks like in in Jupyter. notebook. Let's see that. So remember, we have a marks
    series object, and we have a grades series object. Let's now make grades. Maybe, maybe
    the name is rates, okay? The name is like grades. Okay, so grades object, this one,
    let's make a data frame.
    Let's say D, or maybe whatever name you want to do data frame with, again, that data frame
    can also be defined using a dictionary. Again, now we have let's say, marks is the key for
    data marks. And grades is the key for data grades. Let's say let's say we define a data
    frame like so. And now if you see if you just display this D, we get a very beautiful look
    and feel of I mean this as the index is the explicit index at index a, the marks, the
    marks is 85. The grades are for at index B, the marks are 75, the grades are 33.5. And
    so on that that looks like so not only that, you can just transpose it like you have transpose
    to a NumPy array, and you will get the flipped version or the transpose variant if you want.
    Great. So that's how and you can have for example, more dictionaries to concatenate
    together and more columns will be added here. And that's what the real data looks like.
    I mean, it has a lot of columns, which normally are attributes. And each row is basically
    one record or one sample of the data that you want to work on. So this data frame is
    really, really ideal data structure for working with files, having a lot of records and you
    want to manipulate the data and stuff like so. So yeah, so one more thing, let's let's
    access the D, for example, that's brand D, that's the, that's the D, let's access the
    values inside D, other than No, so what are the values, so, the values inside D is completely
    again, a two dimensional array that is completely like so. So for example, if we want to access
    this particular element 65, that is row number three, and column number one, excluding the
    indices at row number three and column number one. So we can access that particular value
    T dot values, just assuming that dimensional NumPy array, row number three is to index
    with do and column number one is index with that, and we will be able to access 65. Wow,
    great. So that is there. There are more things that are available d dot for example, columns,
    d dot columns, columns, it will give us what are the columns, the columns are marks and
    grades. There and there are other properties. And there are other several properties that
    we need to know Rs, for example, this there, we define this as di d dot index and stuff
    like so. Okay. One more thing that you need to know is we can repeat right now we have
    that sub D, that is this one. That's the D. Let's say we want to add another column here,
    just we want to add another column here. And that is the name of that column is scaled
    marks. And the scale marks are what if we have computed marks, rather than from 100?
    What if we have computed marks out of 90? What are the scaled marks up 90? So one way
    to do that, and very quick way to do that is just like a dictionary, again, like a dictionary,
    you just add a new key, let's say, scaled marks, that's a new key. and the value is
    simply all the marks column divided by 90. So is that true? No? divided by 90, if we
    have just completed all the marks by 90, and then how can we? How can we compute the marks
    from 90? It is rather than 100. It is from 90, I guess? How can we compute the marks
    from 90? If you want to compute the marks from 90, I guess they will look like and divided
    by 90. And maybe 100 is multiplied here. I guess maybe the formula. I guess that that
    that's what it is, I guess let's see. So now if you see D, there will be another column
    that is there. And oh, it does something else. Anyways, it does something that Yeah, so something
    anyways, so we see we have just, I mean, we've just computed this, we just
    we just found that we just inserted that column inside that I'm in, there is a process for
    each of these kinds of values. Maybe we have added this column in a very wrong way. And
    later on, we suggest that okay, we should delete that column. Well, that's very simple.
    Again, using the concepts again, just like the dictionaries, delete this, and this column
    is deleted from data. And you're again with the data that you had. So you can add columns,
    you can delete columns, and indexing is really fine. I mean, indexing like like masking,
    let's say, you want to bake for example, or you want to bake the DataFrame such that you
    want to pick all the records such that the marks are the marks are. The marks are greater
    than let's say, greater than, let's say 70. You want to pick all the records where the
    bulk of the marks are greater than 70. This is that simple. All the data will be will
    be copied into g with this condition. And this condition can be arbitrarily complex
    using ands and ORS and combinations and all that stuff. And you have seen this kind of
    stuff in NumPy as well. I mean, this is called Okay, great. So that's available in pandas
    as well. Okay, so that's how you can index in the next. In the next video, I'm going
    to basically show you one type of problem that normally happens in real data that is
    the missing value problem. Sometimes you read a data and some of the attributes or some
    of the row column p values they are just missing. I mean, they are not available due to certain
    reasons. How can you How can you handle those values? And how actually pandas suggest you
    to handle those kinds of missing values, which are sometimes called Nan values or non type
    values. Also, they they mostly used interchangeably in pandas. So in the next video, we are going
    to handle or see how to handle missing data in pandas hope to see you in the next video.
    Okay, in the last video, we saw data frame object. And we saw actually how to add and
    remove columns how to process data, how to index how to actually mask or how to apply
    conditions and selections in in bond as we saw that very briefly, but in this particular
    video, we are going to see one kind of missing value, sometimes called name or not a number,
    or maybe not anything or sometimes this nun type none, which is the default return type
    of any function. In Python. This non type is also sometimes in pandas is treated as
    Nan or Nan is treated as none or interchangeably. Any anything. Let me give you what do we mean
    by that, let's say we have two dictionaries, let's say one dictionary is a with key value
    a and value is one, then B and the value is two. Okay? The other dictionary is B and C.
    So for example, that is one record with columns A and B. So a and b are the columns. On the
    first record, the value of a is one, and the value of b is two. Now let's say we want to
    insert another record in the same data frame. Now the value of b is available in the second
    time, well, if b is available, which is three, and the value of c is available, which means
    a C column is added now. But for the value c the first row value is not available. So
    we will say this value is missing here. But in the second row, we have four similarly,
    the value of a is missing for for the second row, and that is a missing value, which is
    sometimes called Nam. So these are missing values. And they are typical. When you are
    working with data. And you're reading data on you're getting data from, from out from
    somewhere or large files and stuff like so. So pandas give some methods to handle these
    kind of
    these kind of I mean, this kind of situation, let's say let's say a equals PD dot data frame,
    data frame, again, a dictionary, let's say we have a,
    one and B, let's say four, that's the first row or record. The second record, let's say
    is another dictionary, let's say B is minus three, and C is let's say, nine. That's it.
    That's it. That's our data frame a. So now if you bring this a if you see the data inside
    a, you will see Oh, what's the problem? Is this and be heavy? Have you played something
    in a wrong way? Let's see. Oh, we have to create a list. That's okay, we have to create
    a list of it, you have to create list of dictionaries, that's the proper way of calling it. So we
    missed just this index list of that. Okay, right. So now we have this A, B, just call
    that a and this value is missing and that value is missing. And in large data files,
    this is typical, I mean, there are a lot of values that can be missing. One way that pandas
    supplies to hell these missing values is to just fill these missing values with some some
    fixed number for example, there is a fill na function, fill any function and let's say
    you supply as zero that means wherever there is a not available or not a number value,
    fill that with zero, or maybe any any value you want to fill that with. So that is One
    way to do that, and now if you see the value of a is all the non values are filled with
    that, another kind of function that is available in pandas that is sometimes used a that is
    drop na that that function drop na, what that does is it drops all the records that contain
    a missing value. Sometimes if that is visible, I mean dropping all the records that contain
    missing values, if that is visible, then go for that. But if if the if the missing values
    are a lot and they are spread over a lot of rows, then dropping all those kinds of records,
    they will create a lot of I mean data loss and and then it becomes really, really important
    how to how to handle these missing values. However, you can fix you can fill the missing
    values using fixed value or you can drop them and later on we will see in scikit learn that
    there are other ways of handling the missing values as well, you can fill the each column
    missing values in each column using an average or using for example, a regression there are
    ways to to handle these missing values. But in pandas, these two functions are right away
    they are you can fill all them with a fixed value for example or you can drop them and
    you are ready to go. Okay great. Next, we are going to see oh as as I mentioned earlier,
    what is the what is the confusion between what if there is a confusion between implicit
    and explicit indices. And that I will discuss in the next video basically, just to give
    you a look and feel what if the explicit indices you supply they are one three and five. And
    what if you call this this particular command one colon three, will it call the implicit
    index or the explicit index, that's a problem. So we will see because 1.1 colon three, one
    and three they are also explicit indices. And whether this one colon three is referring
    to the implicit indices that are default indices, or they're referring to these indices. So
    this confusion is there and we will see how to handle that confusion. Using this lock,
    LLC function and index lock ilsc function, we will see that in the next video, hope to
    see you in the next
    video. Okay, in the previous video, I mentioned a confusion that can be there, if you have
    supplied the explicit indices that can conflict with implicit indices. In particular, for
    example, if this is the series object, or maybe a data frame object if you want to if
    for indices, let's just think about the series object, it has these values ABC with index
    one three and five, if you for example, access a particular element let's say data with index
    one that means the explicit index for sure, but if for example, we slice the values for
    example, one colon three, the default behavior of slicing if you give an American disease,
    that is to use implicit indices, and by implicit indices, we mean by we mean that what is at
    index one at index one this is b, so B will be printed for example, or B will be fetched,
    and then you move to do which is C then C will be fetched, and these are the values
    that will be printed, but the behavior might be different, you might be expecting to use
    explicit indices, which means access one colon three, and when the explicit indices are used,
    the last index is also included. And in that case, you might be expecting the index one
    is of a so as should be printed, and index three is of B and B should be printed. And
    this configure might be there if if this is there. So to handle that there is there are
    two functions one is called l OC. And another method is called i l OC, whenever you call
    LLC, that means you are using explicit indices. I mean, you're forcing to use explicit index.
    And whenever you call, I LSE that means you're accessing elements using the implicit index
    what whatsoever. So let's, let's practice this and see the confusion. See the detail
    of this kind of confusions in in here Jupyter Notebook. So let's say we have a series object,
    let's say a equals PD dot series. And let's say it has values as a, b, and c, NASA value.
    These are the values and index as let's say One, three and five let's add these are the
    indices let's say this is eight Okay, let's say we access a using one that means that
    means the explicit index and that is this let's say B access and using the slicing operator.
    Now, this will use implicit indices and it will access I mean it will access these B
    and C because one colon three using indices implicit indices results that and we might
    be might be expecting that use this kind of stuff. So, if we are really interested in
    using explicit indices, what should we do is we should call the lat function a lock
    and then one colon three that means, use explicit indices there is to remove the confusions
    now, it will use the explicit index one and three and if for example, we are interested
    in using implicit indices, then it is good to use ilok function Yeah, now, one one column
    three is to use implicit indices and the implicit indices are like these. So, and like in series
    objects you can you can you can do the same in data frame objects. Once you are using
    lock and ilok then the further indexing inside these square brackets is exactly the same
    like NumPy. So, whether you use log or ILOG, the indexing mechanism is exactly that the
    slicing mechanism is exactly the same like, like you you you have used in in NumPy. I
    mean all indexing that stays the same log means you're using explicit index ILOG means
    you are using explicit implicit index. Let's say for example, we have our data frame, I
    guess D, that's our data frame available to us. Let's say I want to access d dot ilok.
    Let's say I want to access the second row completely the second record, oh, the record
    that is indexed at look at an index at two, which is a third row completely, let's say
    I want to
    access that. Now this two is acting as this two is acting as, for example, if you see
    the the second row or the or the row at the second index, which is a third row that is
    completely this edit returns that once you have used a lock, for example, and mostly
    people use ilok. Sometimes lock is also required. But I log is just to explicitly mentioning
    that I'm using I'm going to use the implicit indexing scheme. Again, you can consider hold
    that thing as a matrix. And once you have applied this eye lock, then you're free to
    play with the indices, like you play with two dimensional arrays, for example. I want
    to for example, I want to reverse, for example, all the rows and I want to reverse all the
    all the all the structure, for example, let's say I want to do that. And you can see everything
    is reversed. I mean all the indexing like like nine by all indexing is there in, in
    pandas. I mean, once you have used ilok inside is just just remember the NumPy indexing and
    everything like so. Okay, so that's the log and I log function. In the next video, we
    are actually going to going to just practice the pandas to actually to actually work on
    our data file that is saved as a CSV file. So we will, we will show you how to how to
    actually add how to actually manipulate read and write the data and play with the data,
    the data, the real data that is there in in some CSV file, and how pandas will help you
    to to manipulate the data very efficiently and very quickly. So hope to see you in the
    next video. Okay, in this particular video, I will be talking about real data set. The
    data set I have chosen just to show you some some functions that are available in pandas
    to work on real data set the data set I've chosen as COVID-19 data set that was available
    on kaggle. And it's surreal data set that contains information of victims recovered
    the total number of recovered people in per country per province, the total number of
    died people and the total number of number of reported people per date available that
    that data is available. Let's see the look and feel of that data in a file. Just to just
    to see what kind of data we are talking about. Let's say this is our data. This is the serial
    number column that contains just the record number. That's, that's a column called observation
    date. That's a date, that's a province or state. That's country or region that's last
    updated when the record is updated was the time and how many confirmed cases were there
    at that date, and how many deaths at that date and how many recovered at that date,
    as the date is moving on and on, you will be seeing that the number of confirmed cases
    and the number of recovered cases they will be increasing, maybe the number of deaths
    they also increase. So let's see this data. Let's read that data using pandas and do some
    manipulation of this data and see the look and feel of that data. In Jupyter, notebook.
    Let's go to Jupyter Notebook and see. So first of all, I need this pandas library and pour
    it that maybe somewhere I need this NumPy library as well. I'm also learning a psychic
    learn SK learn library because I want to, I want to use impute function, just to handle
    the missing values, it is just more powerful to use the I'm in the SK learn library there
    is also a Data Science Library package that is particularly a machine learning library,
    or our package that actually gives a better support or a larger support of handling missing
    data. Although here I have used this SK learn function just for an example. And but but
    I could have used this data frame fill any function or something like so but I'm just
    using that one. Okay, after importing all these, what I did is I just call PD dot read
    CSV function, and I load that data and then I did this stuff one by one. Let's, let's
    let's spend some time on all these commands one by one. And let's see in Jupyter Notebook,
    what is happening, let's go to Jupyter Notebook and actually read that file and do whatever
    we are doing here. So first of all, import NumPy that is already imported. Import.
    For example, pandas that is also already imported, then from SK learn dot impute import simple
    impurity. So let's let's use that or let's Okay, let's do that. From SK learn dot impute
    SK learn dot impute import simple in pewter, okay, import that because that's a new thing,
    we need to import that now read the data, for example, data frame in df. So df equals
    PD dot read CSV. There is a CSV file read CSV. And it contains the path of the file.
    The path is located in my directory, it is located at this particular location COVID.
    And the name of that is COVID, underscore 19 ESCO data. So COVID underscore 19 underscore
    data dot c s v. So let's read that file, the file will be read, if you just see that some
    of there is a function, let's say head that gives the top records or the records that
    appear just the very top that's that's what the data file that I was showing you in Excel,
    it is showing just the first five records, I can show the first 10 Records, for example,
    just by calling the head function in this particular way. Okay, great. Let's say I just
    want to remove this real number because I think that is not required. And let's say
    I want to remove this particular column. Because that is also not required. There are multiple
    ways of doing that. I can call an t l function on this. And I can call the L function on
    that. But there is another way of doing that by df dot drop df dot drop and in that you
    just give the columns that you want to drop one column is serial number, I guess, what's
    the column name? That's s and No. So you want to you want to drop that column and then you
    want to drop this particular column with herring last update. So that is last update. So that
    is I guess what is there
    Xs one in place Drew. So Xs one is justments. Mentioning, do do that stuff with columns
    in place, equals true. That actually is, is telling that whatever this operation you are
    going to do reflect the changes in this df frame. If we do not write in place to it,
    we'll do everything and return onto a temporary variable or underscore variable or whatever
    we are saying, but the DF the data frame will stay unchanged. So in place true means do
    that changing in df variable itself. So now if we see df dot had flat say, it will no
    longer be showing us the serial number column and the last updated column. What next we
    can do we may we may want to rename this, this name to just date. For example, this
    to maybe another, let's rename all these columns, using using the Rename function, df dot rename
    columns equals two and then we have that dictionary again in place equals two. So let's use let's
    use this read in function, TF dot rename. Let's do that. And here we have columns, columns,
    if I spell right columns, and then that is dictionary what columns you want to change,
    I want to change observation date, I want to change that to simply date, let's say and
    I also want to change province slash state to simply simply state, our province province
    that say simply that and I also want to change this country slash region to simply country.
    So, maybe I want to change this country slash region to simply due to country cru and try
    country and I want all that should be happen in place. So in place equals true. So after
    that, if you run that, on this particular step, and now if you see the state of df,
    you will get like
    so. Okay, these many, so they province country, confirm debts, and so on. So this is much
    nicer form than earlier. Moreover, we may have a lot of missing values, oh, one way,
    this date format, the date format is not in a format that pandas internal date format.
    So let's convert the date format into into into the internal pandas date format, using
    to to PD to date time function. So let's say df date equals to PD to date time, and convert
    this df date in that particular format. And now if you run this TF dot had to might be
    seeing the date format in a different way. See that that's the that's that's the date
    format that the pandas is expecting. Now, we that that is just showing showing some
    records if you want to see more records, we can see those let's say I want to just I want
    to just count or let's say let's just describe all the data at TF dot describe there is a
    describe function that describe all most of the statistics of the data, I mean, the total
    count of confirmed cases are these the deaths are these recovered are these these many columns
    are there these many values are there. The mean is that and standard deviation is the
    minimum 25. And these are the statistics. Let's say there is another function info df
    dot d A dog info. If you call that function info, it will give us the more information
    about the null increase and the nominal increase and so on. For example, if you see the total
    number of data columns are six, the total number of records are 6162. The date increase
    is always available. The province entries are only 3700 available, the rest increase
    our null increase, so province increase most of the increase or null increase and they
    are there, maybe we want to drop those or maybe we want to impute those increase and
    stuff like so, but they are not increased that are available in the province column,
    some of the province, some of the province values are no longer available. Let's see
    that here. For example, this is not available, this is not available, this is not available.
    And that's what the real state of the data is this is not available, this is not available
    and so on. So this can happen. Okay, next, what we do is, we actually be actually use
    the simple computer just to impute the missing values. One ways to do that using simple mburo
    from SK learn. Another way is, as we already know, just df dot fill na fill na with, let's
    say a bit let's say not available with let's say a string, some string not available, that's
    it that string and with that, if you fill that fill any using that now, after that,
    we will be having all that data, the missing values will be filled according to Let's see
    some missing values because in the province there were some missing values. Now you can
    see for example, let me go on and left Yeah, so not available not available, we can we
    can use that or we can use a fancy kind of thing that is available by a psychic learn
    and so on. Okay, after that, if you now see the information info, now, you will not be
    seeing any null value, all the columns are there, oh, this was not in place. So don't
    fill na that is let's change the DF with it. So this doesn't happen in place, df just changed
    the DF. Okay, df changes. Now, if we now call the info, there is no null value anymore.
    Yeah.
    So I am this video here. In the next video, I will show you this group by command to just
    see these kind of stuff in a more detailed way. Because this this particular video is
    getting lamp here lanthier. me I'm stopping here in this particular location. Next time,
    I will show you the group by command in the in the panda's data frame. And I will show
    you what that does. So, we will explore all that code that is written here. And we will
    have in the in the upcoming videos when we will see the plotting and matplotlib we will
    be using the same data file to work more. And to get more insight how the how this pandas
    and matplotlib and NumPy in combination how they can actually how they can actually play
    a very important role in analyzing a very, very large real data files. Okay, so I end
    this video here. I will start the next video right from this command. And I will tell you
    what is happening what is the scope baikman so hope to see you in the next video. Okay,
    in the last video, we were discussing this COVID-19 file, and we reached here but we
    didn't use this SK learn in pewter, we just use the fill na function of data frame. Now
    let's discuss this group by command or a Curie in in pandas that is much more visible. Let's
    say our goal is now for example, if you go to go back to Jupiter, if you see your dear
    df dot head, or all, at the D f dot head, let's attend records. If you want to see that
    there are so many records, let's just see 10. Let's see, what you want to do is you
    want to just see how many, how many total confirmed cases are there in each country,
    regardless of their date. And, for example, you want to just see all the all the all the
    confirmed cases, all the deaths, and all the recovered cases in each country for all the
    dates and for all the provinces combined together. One way to do that is to write a group by
    command for example. That's a df two equals df dot group by and in group by what you see
    is for what kind of columns you want to you want to group all these all this data. So
    for example, you want to group by country. country. So that's your grouping. Now after
    gopeng What do you want to see what kind of what kind of what kind of, for example the
    values you want to see because now you're dropping? Well after grouping I really Want
    to see because data is gone once I drop, all the dates, they are grouped together all the
    prevents that are grouped together. So, what I really want to see is just the country and
    I want to see the confirmed cases. So, pick all these records confirmed, and then I want
    to see deaths and recovered. So, for example, if I want to deaths, and let's say then I
    want to see the recovered cases are E and just I want a big group all the countries
    together group all these things together and add all the records under each country. So
    sum all of them, and maybe we want to reset any index if it is there. So for example,
    preset, we set index. So that So, after this Curie For example, this group by query, what
    will happen is this df two will contain a summary of the data with respect to each country
    and the total for example, in this particular country, the total confirmed cases are these
    all confirmed cases till now, and the deaths of these and recovered as these for this country
    for each country, now, each country is describing Australia for example, in our till, till now,
    Australia has total these confirmed cases, these total deaths, and these are recovered
    cases and so on. So, that is if we want to group all these with respect to country, what
    if we want to group all these with respect to country and then date for example. So,
    first we want to group them by country, so country and then for each country, display
    all the dates, and then do the same stuff, the the Curie will stay almost the same. A
    group by command will say almost the same with one kind of
    with one kind of let's say we want to first group by country, once the, it is grouped
    by the country, then I want to group them by date. And now I want to see all the results
    in the form of I want to see the data as well. And what will happen now is for each country,
    its trend with respect to all the dates that will be displayed here. So let's see df two
    now, df two. So if you see df two now, you can see, for example, this particular country,
    it has just one record in this country, it has one record, then this country for this
    date has this record for the same country and other date has same record and all the
    data is also sorted. I mean, now you can see all the records in a very incremental way.
    So that may give you a very good look and feel of what is happening or, for example.
    Another thing What if you want to what if you want to, for example, find out all the
    records, all the records, you just want to find out all the records? Let's do three,
    four, which the the confirmed cases, for example, the confirmed cases are are more than 100.
    Let's find out all the records. Let's, let's let's let's get just let's just pick all the
    records for which the confirmed cases are larger than 100. And let's copy all these
    records just those records in this. So if we do that, we have d3 available, and we have
    d3. This, I mean, these are just the records in which the confirmed cases are for sure
    larger than 100. Just those. Yeah, so we can do. I mean a lot of a lot of data analysis,
    the real data analysis, a lot of a lot more, I've just shown you a very small snapshot
    of what we can do with pandas on the real data set. I mean, there is a lot more that
    we can do with this pandas library, on real data sets on multiple data files, combining
    them together, joining them together, seeing their correlation, a lot of stuff. And this
    pandas really is a very, very fancy and very high level library, very high level package
    to work with data. So due to time limitations, I'm just ending this pandas here although
    there is much more to explain in that, but in the next video we will be jumping towards
    matplotlib just we will see some some functions of matplotlib. And we will see very briefly
    how can we plot How can we analyze data using visual graphs or stuff like so. So, that that
    sometimes this visualization of different attributes of the data give very good insight
    to the data wherever possible, wherever possible. If the visualization is possible if the data
    dimensionality in a way are the visualization techniques are in a way that you can visualize
    the trends in the data, that gives you much more much better insight than the numbers
    or statistical results, but it completely depends in what situation you can visualize
    the data there are situations, high dimensional data, for example, is not always visualizable.
    So, in those cases, the statistical results of the numbers may play a more important role.
    But in more in many cases, visualization give a very good initial insight into the data
    and the design process can become very, very fast if you know something about the data,
    whether you get that information by visualization or by other statistics or whatever. So, in
    the next video, I will be just explaining some very few functions of matplotlib. And
    then we will be, then we will be exploring the same file, and we will be doing some stuff.
    Doing some stuff using the plots and matplotlib. And doing, seeing the trends of death rates,
    seeing the trends of I mean, we'll be playing with this file a bit more using matplotlib
    as well. So hope to see you in the next video. Okay, in this video, I'm going to discuss
    matplotlib a very powerful package for plotting graphs and scatter plots, line plots and 3d
    plots and plots on the globe and whatnot, I mean, very, very powerful tool. The most
    important module in this matplotlib, or the most popular module, or the most used module
    is biplot. So we can import matplotlib.pi plot as PLT. Another way of writing the same
    kind of stuff is we can we can write like from Matt matplotlib
    from matplotlib import by plot as PLT. So either way is fine whether we write this as
    a documentation or that one that is fine as MP is for NumPy. So let's create some points,
    just just just make our first plot. Let's, let's make some points starting from zero,
    let's say all the points starting from zero till 10. And let's create 1000 points in between.
    One way to do that is to use built in function or a method in NumPy, which is linspace or
    linearly spaced points starting from zero ending at 10. And there are 1000 of those
    points. Let's say this is our x and this is our let's say y which is NP dot sine, the
    sine function is actually will apply element by element on this NumPy array. And then this
    PLT will plot will actually plot x comma y all the points in front of you. So let's go
    to Jupyter Notebook and actually see this matplotlib in running form for the very first
    time, oh, we have seen this matplotlib. When we saw NP dot random, we only plotted a histogram.
    While this is not the first time we actually have seen this once, once, once before. So
    import mat plot lib.pi plot as PLT. That's your import command. For example. Now PLT
    is available. Let's say x is NP dot Lin. space. Let's start from zero. Go to 10 and generate
    let's say 1000 points. That's it. That's your x, y might be your MP dot sine x. That's it.
    That's your y. And then what you do is you say okay, PLT dot plot, x comma y point by
    point, and then you press Shift, enter. That's it. Oh, this plot is there in front of you.
    That simple. I mean, that simple. Can you imagine? This? Is that simple? Yeah, this
    is that simple. So I'm in plotting. This is a line plot. For example, if we want a scatterplot,
    we can say okay, PLT dot scatter, there is a scatter function that allows us to plot
    all these endpoints form rather than rather than this line form. These are all these a
    lot of points. That's why you you're not seeing these scatters. So let me let me let me take
    this n x s viewer. Let's see. Let's take x as let's just take a few points, let's say
    just just just 30 points. Let's see the corresponding 30 points, see, they remember the indexing
    of NumPy arrays and just using that. So now use the scatter plots, and you have this,
    oh, that's a scatter. Maybe we want to use, let's say, start from the very beginning,
    due to end and big every, let's say, attempt point. And do the same with why, just to just
    to see a plot in a better way, just sample some points. So that's the scatterplot. It
    is just like I'm in the points and so on. It is not a it is not a continuous plot, like
    the line plot, it's a scatterplot, we're going to annotate this scatter plot, we can change
    these colors to any color we want. For example, we can we can have a prop property, for example,
    color is equal to let's say, red, and everything will become red. Yeah, so that's right, we
    can have I mean, we can label it we can x label it, we can via label, there are a lot
    of properties. But but the but the main point is plotting is that simple plotting is that
    quick, using matplotlib. So yeah, this matplotlib is really, really powerful, we have just seen
    a snapshot, just a plot function and a scatter function there, there are a lot of properties
    to be said, there are a lot of things to be considered. And we will see we will see actually
    one one lanthier good use on this COVID-19 file. And we will we will actually analyze
    the data trends and the confirmed trends and some trends that and we will plot them and
    see the trends really using matplotlib. So But before that, let me let me show you that.
    If you call for if you call this plot multiple times, for example, maybe with different colors,
    then you will be having a lot of curves on the same on the same plot, for example. So
    for example, let's see PLT dot plot x comma y, let's say with with color, let's say color
    equals to blue.
    You can write blue, the whole or you can like write just be that's fine PLT dot plot, x,
    and let's say NP dot cause x and the color you are interested in, and let's say the color
    is, let's say green. And that's perfectly okay. And that will give you two plots in
    the same figure, sort of, and you can just good to go. Well, yeah, so that more you can,
    for example, you can plot with a green, green color, and you want the solid line, or you
    want, for example, Seon color in a dashed line, or you want a dash and dot black line
    or, or maybe you want to completely dotted line in red color. So there are several things
    that are available in matplotlib. This is just a very few very simple snapshot. And
    I have given you a very quick start in and actually actually the whole point is using
    Matlab is that quick, I mean, you can you have your data, you just plug in their data,
    you just call the plot function, and you're good to go for analysis. Okay. In the next
    video, we are where we will actually walk through the we will actually walk through
    the COVID-19 data set. And we'll actually analyze the trends and to add the death rate
    transfer each country individually, and then we will see the depth confirmed and the recovery
    trend of the overall world till the 16th of March till the day till the data data is available.
    So next video will be actually the viewer will see the running form of pandas and matplotlib.
    Together, so hope to see you in the next video. Okay, I already have shown you the COVID-19
    file. And here I have a notebook on that that uses matplotlib and pandas to find out the
    depths conformations and recovery trends using using different plots. So let me import all
    the packages that I need. I need a plot by plot function from matplotlib. I need pandas
    somewhere I need NumPy. And I'm using a simple mburo here for missing values. So let's run
    this. Let's run this command. And yes, everything is imported. Now let's load the data that
    I've shown you earlier. The data is available now. And let's run this thing that is the
    first 50 Records. Yeah, remember that? Yeah, so that's the data that is available if if
    you just want another view another view of the data That's the data file, which is COVID-19
    file. And it has observation day province country, last update, confirm, to date, death
    to date and recover to date for each country and for each province individually. Okay,
    great. So that's what we have. Now what we can do is, now let's drop the serial numbers
    and last update using in place that and rename the columns that we did already in a previous
    video as well. Let's convert the date into the pandas built in date, frame. Okay, let's
    use the psychic learn in pewter, sk learn in pewter, using the constant strategy, there
    are a lot of strategies there, let's use a constant strategy. And this period or data
    frame, in pure dot fit transform that will help imputing all the missing values with
    a constant strategy impure. So that's there. Okay, next, let's apply this group by command
    and group all of all the records using country for each country. And for all the dates, let's
    sum all the records that sum all the values of records deaths and confirms using this,
    but now let's first country and then all it state, then the second country, then all it
    states and so on. We have seen that in one of our previous videos just running that again,
    just for a double check. So that's what the data state is. So country one all it states
    country to all it states. So this country has a lot of dates, then another country and
    so on. Next, let's see how many countries are there. In total, how many unique countries
    are there. So what I, what I do is I find the column, I actually pick the column with
    country and call a unique function on that. And that gives me all the countries without
    repetition. And I just compute the length length of countries tell me how many unique
    countries are there in this data file?
    There are 171 countries. So now my goal is for each country, I want to see what is the
    trend of with respect to the date as the data is moving from the first day till 16th of
    March? What is the trend of death? patients? What is the trend of recovered patients and
    what is a trend of confirmed patients as the data moves on. So because we have 171 countries,
    so let's loop over each country again, again, and again, let's loop over what we do is for
    ID x in the range of this, that's the loop you remember that. And what I do is let's
    find out the indices where the country is like this, let's find out the index all the
    indices where the country is like that. Then what do you do I make a scatterplot. That,
    with starting from this, and that, I just pick the confirmed cases and all the confirmed
    cases for this one country, I just pick those. And I look, I do that using this scatterplot,
    then I use another scatter plot, just to get all the recovered cases, then I do another
    scatter plot to get all the depth cases. And then the title of the title of my figure becomes
    the country name, the x labels the days, days since the first suspect, the wire label is
    the total number of cases, the legend command actually will be there that will show what
    eat that is in. So these kinds of labels that are rewriting here, they will appear in the
    figure, then we force them to show that in each iteration show the show the fourth. So
    this will show the trends of confirms to cover some deaths for all 171 countries one by one.
    So if we run this command, we'll be having 171 plots in front of us. Let's see all of
    those one by one. So yeah, so this is for the country. It has just one such thing. This
    is for that this is for Afghanistan. As these moves on the confirmed cases that are even
    blue, they are moving up. These are the number of cases. These are the number of days since
    the first day. And the green is the number of recovered cases for Albania. That's the
    trend for Algeria. That's the trend. I mean, these are each and everything is a separate
    that is for Argentina. That is for America. This is for America till 16th March, by the
    way, today. The new says that America is really in as dangerous position anyways, that's for
    Australia till till the date we have to do that is for Austria. Yeah, so these are all
    the trends for all the countries. You see I'm in the matplotlib how powerful that is.
    Although I walked through this code very quickly, but you can see this video again and again.
    And then check how that happens. Yeah. So that's what this is for Finland. Oh, Finland
    is also in trouble. So France. Okay. So that is for Germany. And yeah, so all the countries
    that are available in data set, they have these kind of plots. This is for Hong Kong.
    And this is for India. And this is for Italy's or Italy's. Yeah. So that's it. So that is
    for each country individually, what if we want the overall trend, or the overall confirm
    and the deaths and the recover trend for all the world together, so what I do is I big
    I grew up all the data with date. So I pick the first date, and add all the records, then
    the second date for all the records for all the countries and so on. And then I plot the
    trend using the scatterplot, again, confirmed record. And that's for all over the world
    and see the trend, where the world is moving. So that's the trend of the world. As the days
    are going on, these are the depth grand, that's a recovery trend. And that's a confirmation
    trend that is moving on. Although I walked through or this notebook, the notebook will
    be available to you. I walk over this notebook very quickly. But the goal was really to show
    you the the I mean, that was a file may not be that informative, if you see that in Excel,
    but now it makes much more sense. When you see these blobs you know what is happening
    and you have insight in the data. And later on, we may we may want to predict we may want
    to make predictions. And the next date what is going to happen, we may want to predict
    using this plot or using some Machine Learning Library like psychic learn or TensorFlow or
    something like that. Okay, so that's it. I can talk much more about pandas NumPy matplotlib
    of there are so many other data science packages, very important packages, one of those is SK
    learn, we can that is for machine learning basic machine learning. Then there are other
    packages like TensorFlow for deep learning by torch for deep learning. There are a lot
    of packages with a lot of speciality is in data science and stuff. I just discussed a
    few of those the most important of those do to manipulate the data to make predictions
    to make classification or regressions. For one, one way is to go to SK learn or psychic
    learn. And if the data is huge, and you have a lot of large amount of data, and you have
    good expertise or deep learning, then you should go to either TensorFlow or pytorch
    these are the Python packages that are available for predictions, classification, regression
    and a lot more, but either way, whether you are going to use scikit learn whether you're
    going to use TensorFlow or pytorch either way, you have to use pandas NumPy and sometimes
    matplotlib to pre process the data and to make the data ready for for these kind of
    libraries to to perform predictions, either a either in the form of classification or
    in the form of regression. So so so this whole course was about for for beginners who want
    to who want to learn Python, specifically, I discussed a lot about the in a lot about
    Python in general, then then then I spend some time not a lot amount of time sometimes
    on exploring the data science packages as well. But, I mean, there is no end we can
    explore more, we can talk about the packages more we can talk about other features of Python
    more, a lot of I mean, input formatting, output formatting, modules, packages, standard template
    library, file handling Internet Access database,
    I mean,
    this is a whole universe, I have discussed a few things for beginners. But But these
    few things were very carefully selected for data scientists. The if you have this course
    available to you as you have gone through all the course, you now have a very very good
    understanding and now you can you can move towards further edit advanced courses towards
    data science and you will be ready to implement the concepts in Python using using the packages
    I have discussed so far. So I thank you all and good luck.
    English
     
     
     
    AllData sciencePython pandasC++RelatedFrom freeCodeCamp.orgRecently uploadedWatched
     
  • Preview
List Download