Hey peeps! Are you excited to begin with the new chapter in Python? Till now, we have been learning the data types and their related concepts. Now, we are starting a new chapter where you will learn the details of Object Oriented Programming or OOP. We are moving towards the advanced level of programming in Python, and here, you will go through the complex but interesting concepts that will show us the fascinating results on the screen. This will be more clear when you will know the basic information about the OOP, but before going deep, we will go through the headlines of the lecture:
How do you classify the programming languages?
How do you introduce the OOP?
Why object-oriented programming is important in Python?
How do you define class and objects in OOP and how are they connected?
What are polymorphism and encapsulation?
How do you use the inheritance in OOP?
How do you understand data abstraction in OOP?
What does method overloading mean?
Keep in mind, it is not a specific concept with Python but any higher-level programming language that supports the OOP has the same concepts and we are using a very general way to describe all the concepts.
Before going into the detail of this topic, it is helpful to understand why we are emphasizing on the OOP and its importance. Actually, there are different types of programming languages and being a programmer, you must know the basic categories. Some of the important types of programming languages are:
Procedural Programming Language
Functional Programming Language
Object-oriented Programming Language
Scripting Programming Language
Logic Programming Language
Out of which, we are interested in the OOP. The reason why the type of programming language is important, it describes the paradigm of the language, and therefore, we can understand the nature and the importance of that particular language in the profession you are using it for. Here, we should know what exactly the “paradigm” means:
“A programming paradigm is the concept to which a programming language's methodology adheres."
Paradigms are significant because they define a programming language and its operation. The classification of the programming languages is done by keeping its paradigm in mind and in this way, the programmer may choose the type of programming language that exactly suits the application for which the coding is required.
You can see that OOP comes in the imperative paradigm. In imperative programming, the user typically interacts directly with the computer's state, deciding how things should be calculated. In this way, more control is in the programmer’s hands, which is the basic source of attraction towards this programming language. In the practice of programming, I am sure you have touched other types of languages as well at any point. So, it becomes easy to compare and practice the code.
In real-time education, different types of subjects are taught to us by teachers. We are moving from basic to advanced programming in this course; therefore, we have covered the concept of data types before. This time, the OOP is our source of attraction, and we are going to learn it deeply because the programmers, most of the time, deal with the OOP when they are using the practical applications of the programming. Let us look at the introduction to the OOP:
“OOP (Object-Oriented programming) is a programming paradigm that organizes and structures code using objects and classes.”
For now, do not bother about the special terms used in this definition. We will learn a lot about them in these lectures with the help of different terminologies. Hence, if anything is causing confusion, do not worry because everything will be clear in just a bit.
The concept of OOP is so vast and important that it is widely used to write powerful applications. The data engineers have to write these applications to access and use the data stored in different entities.
The feature that makes the OOP unique is, it uses concepts that not only make the programming easy but efficient. It is based on the imperative programming paradigm, which employs statements to alter the state of a program. It is concerned with describing how a program should work. One must keep in mind that the main objective of the OOP is to bind the data and the functions of the program in such a way that all of these may work as a single unit but the security of the data remains intact. There are some important terms that you will see often in these lectures, so have a look at all of them.
Class
Objects
Polymorphism
Encapsulation
Inheritance
Data Abstraction
Keep in mind that you have to grasp the concept of each of these terms clearly so that, when you read them with other types of definitions, you may not be confused. You will learn all of these in detail in the coming lectures, but the basic introduction to all of them is given next:
Before going into the introduction of the OOP, one must know that an object is an instance of a class. Object and class are interconnected terms, and a class is defined as:
“In OOP, a class is a basic unit that represents the collection of objects, and it can be thought of as the blueprint or the prototype by following which, the objects are made.”
The attributes of a particular thing, connected with each other, can be represented with the help of the class, where the number of the attributes starts at one and can be two, ten, or any other positive number. In this way, a simple and basic class can be used to store all types of physical or logical information about a particular product.
In object-oriented programming, objects are the basic units of data. An object is associated with the class and is the entity with which the state and behaviour of the class are associated. If it is confusing at this point, do not worry because we are going to discuss the object in detail and will work again and again with the objects.
The good thing about the objects in OOP is that, just like the real-time concept of objects, the programming objects may be anything, whether it is physical, such as a car, an animal, a plant, a cooking item, any food, or any other thing, or abstract, such as any software, a bank account, a soft blueprint, or any document. The positive thing about the object is, it allows us to reuse the same code anywhere in any block of the same code where the same attribute of the object is to be used.
The fundamental concept of the OOP is polymorphism, and it has the same features as the family in real life. To keep things simple, we assume that all the objects belong to the same class, and the polymorphism allows us to use the objects together as they are from the same family. In this way, the same objects can be used interchangeably in the same context. In this way, the workload of the programmer is minimized as much as possible through polymorphism. In simple words, the concept of polymorphism is the same as it is in chemistry, where the same element can be used in different ways when certain conditions are met.
Another feature that makes the polymorphism attractive is the availability of the alteration in the classes, both in terms of their size and the data stored in them. All this information will be cleared up in the coming lectures, but for now, we only understand the basics of polymorphism. In other words, we all know that poly means "many,” and if we talk about OOP, it includes the concept of a class's ability to get the features of already existing classes in this way. For example, you can assign the attributes of a particular product, such as a car, to another car with the same basic features but with different attributes. This is just a basic example of polymorphism, and many people mix this concept with inheritance, but these are different, and you will learn a lot about them in the next lectures.
The next concept that we are going to discuss is encapsulation, and to make your concept clear, let us take the example of the capsules that we get from the pharmacy for different health issues. These capsules protect the inner medicine, and the same concept can be applied to this type of encapsulation to reinforce the concept. Basically, the data is protected with the help of different concepts used in the encapsulation.
The programmers are very sensitive about their codes and the data stored with the help of these codes. Encapsulation is used to give the code privacy and protect it from unwanted users. The private attributes of the code that are enclosed in the capsule are only accessible by the programmer itself. In other words, we cannot use the private attribute in other blocks of code until the programmer himself allows it.
Another important feature of the OOP is inheritance, and this is the point where we can say that the OOP is making Python more effective and easier to use. It is one of the most significant points of the OOP, and with the help of easy and effective Python, programmers can inherit the characteristics and attributes of any class and assign them directly to others. For this, you have to learn about the child and parent classes, but for now, we are leaving this topic here and moving on to the next point that will show us the importance of the OOP, especially when we use it in Python.
If you are interested in becoming a professional programmer, then some points should always be kept in mind, and the most important one is to always go with clean code that precisely describes the code and gives the exact coding without any errors. For this, some concepts will help you a lot, and one of them is the concept of data abstraction. With the help of this concept, the programmer is able to code cleaner because "data abstraction" means writing cleaner code and hiding unnecessary details from the users. It is yet another method for the programmer to maintain privacy from the end user. THE SENSITIVE CODES ARE HIDDEN FROM THE OTHER USERS USING DIFFERENT TECHNIQUES. The whole process of data abstraction revolved around making and implementing the abstraction classes and then calling them in different ways according to the requirements of the code.
Here is a small topic to be discussed that is not a particular part of OOP in Python, but almost every programming language that works with OOP has it. This is also true for other characteristics that we have discussed so far.
In method overloading, many methods with the same name are declared and then called at once. In this way, a single class can take multiple arguments. Other concepts, such as method overriding, are also connected with the same concept, and we will discuss them with some suitable examples.
Consequently, we have almost all the basics of the OOP. We have read a lot about them and tried to make them more general so that the programmers working on them other than Python may also get the useful concepts from this lecture. Actually, the OOP is not just confined to Python, but we have to connect it with Python, and this will be more fully discussed in the next lectures, where all these concepts will not only be discussed but the practical implementation of codes will help us to have a grip on Python. This is an extremely useful topic and therefore, we will move a little bit slowly on these lectures and will understand each and every point in detail.
Hey peeps! Welcome to the new tutorial for the Python programming language, where we are at the point where we are going to learn about the loops. Loops are fundamental concepts in programming, and if we talk about Python, there is a smaller variety of loops in it, but the most important ones are available to practice in Python. In the last session, there was a long discussion about the while loop in detail. We had seen some examples and the details of the statements that can be used within the while loop. In the present lecture, we are going to discuss the second type of loop in Python, that is, the for loop. You will go through the training of every important and basic step about this loop, but first of all, you have to look at the basic list:
Why do we prefer for loop over some other concepts in Python programming language?
What are some basic concepts that every programmer must know about the for loop in Python?
Describe the flow chart of the for loop.
What are some examples that explain the for loop in Python?
How do we use different sequences in the for loop?
What is the range function explain it in detail by using the for loop in Python?
There are other ways to get the same output as we will get in this lecture but using the for loop is one of the easiest and most fundamental ways to get the best results. Have a look at the detail of each question.
The for loop is the basic looping process in Python that is extremely useful in making the basic to higher level codes in simpler way. We all had the introduction of the For loop in the previous lesson, and now, have a look at the following positive points about this loop:
The for loop makes the code very simple and the programmers do not have to pay much attention to make the logic. You can get the idea of its simplicity that the user can initiate the loop in just a single line if all the logic is clear in it. After that, the body of the loop starts. Just like other loops, the For loop gives us the independence to adjust the flow of the code so that we do not have to write the same block of the code again and again.
Different data types can be used in the for loop and the best thing about it is, it becomes super easy to use the For loop to manage the sequences. It would not be wrong to say that For loop makes the working of the sequence best therefore, for loop is perfect for the sequences such as lists, tuples, and arrays. Moreover, the traversing of the sequences is easy with the For loop.
The for loop is not a new concept but in the old higher-level programming languages such as C and C++, for loop is used therefore if a programmer is moving from such basic programming languages to Python, the concept will be cleared before they start it. In other words, the for loop is a generic type of loop that once understood, can be useful as well when they switch to the new programming language.
We know the introduction of the for loop but this time, we are going to discuss the detail of every process that will be useful in the practical coding using the for loop. Keep in mind, loops are the statements and not the whole code. This helps to manage the code in a better way and to reuse the same block by merely inserting it in the body of the loop.
We are discussing the generalized form of the For loop and therefore, all the concepts are very general that we have discussed till now. Yet, the only difference in the coding is the syntax of the loops and therefore, we are discussing it at first to get an idea of what actually is going on.
for iterator in sequence:
statement(s)
It seems very simple here but the statement is not that much simple. The programmers, then using the for loop add multiple statements in different ways to get the required output. More things will be cleared when you will see the flow chart.
The best way to get the concept of the for loop is to check for the flow chart of this loop. Have a look at the picture given next and then we will move towards its discussion.
Here, you can compare the syntax and flow chart and get an idea of what happens when data is input in the for loop. At the start, when the condition is applied on the for loop, the compiler checks for the condition if it is true or not and as you can guess, if the condition is true, the compiler will check for the body code
Different data types can be used with the for loop and we will move from basic to complex ones. We all know about the string; therefore, here is the first example with the string message.
#initializing the message
message= print("Enter the string")
#taking input from the user
str=input(message)
#using for loop to print the message from the user
for i in str:
print(i)
Here, when we run the program, we get the dialogue box it says the “none” word with the dialogue box. This will look strange but it makes sense. With some functions in Python, the return value is mentioned in the output. Since this function will not return any result but will only give us the same string that we are going to input in it, therefore, there is the word “none” mentioned in the dialogue box. We can solve it in different ways but the point I want to make here is to clarify the reason behind this indication.
When the string message is typed by the user, the same message with the same format is shown on the screen but this time, as we are using the for loop, each character is picked by the compiler one after the other and therefore, the result will be obtained in the vertical form with each character at the new line.
Here, you can see the “none” is added by default without a string message and once it is printed, the for loop picked each character and printed it in a separate line. Even the spaces between the words are counted, and we get a clean and understandable output.
Have you tried the code given above? If yes then there must be a question in your mind that what happens if we input any other data type instead of string? Actually, this is not a precise code yet, if we add the restriction to add only the string as we have done in the previous lecture, the compiler will not accept any other data type other than string. Yet, to keep things simple, I am not changing the code as the main focus is on the for loop till now.
Here comes the practice that is specialized in the for loop. Since the beginning, you have been noticing that we are emphasising the sequences. We all have practised them and in some examples, the for loop was used before but since this is a pure practice of the for loop, I have made a program that contains all important sequences in a single program.
#initializing the List to use with the For loop
print("\b Names of the fruits")
fruits= ["strawberry", "cherry", "blueberry", "apricot", "tomato"]
for i in fruits:
print(i)
#initializing the tuple to use with the For loop
print("\b Price list of mentioned fruits")
priceOfFruits= (34.8, 11.7, 126.9,11.6,11.5,22.0,1)
for i in priceOfFruits:
print(i)
#initializing the array to use with the For loop
print("\b Random things and numbers")
items= {"lipstick",3,"papers", 3, "pen", 1, "bread", 3.4 }
for i in items:
print(i)
Hence, the program is clear as we have practised it before. The type of bracket represents each sequence and it has its own characteristics. For loop access each and every element of the sequence and print it on the screen. The arrangement of the items in the array is random and we can not suggest the sequence of the elements because it randomly picks the elements and print them. Hence, every time we run the code, the value stored in the variable i is different and the one, printed on the screen, is never repeated at that particular run time.
The next topic here is the range function that has interesting applications in the fields like gaming. It is because it can be used in different ways as it has the independence of the number of parameters. The syntax of the range function is the same with the for loop as it is with other statements.
x=range(start, stop, step)
Where,
x=name of the variable in which the value of the range is being stored.
start=starting point of the series
stop=ending point of the series
step=The interval between the range member.
Keep in mind, you can use one, two, or three parameters at the same time according to your easiness. Instead of using separate examples for each case, we have designed a program that describes the all. Have a look at the code and then we will discuss it more.
#using the range function to print the table
num = int(input("Enter the integer for which the table is required? "))
for i in range(1,21):
print(num,'x',i,'=',num*i)
#range function with one parameter
print("\b using the range function with only ending point")
for i in range(7):
print(i)
#range function with two parameters
print("\b using the range function with starting and ending points")
for i in range(2,9):
print(i)
#range function with three parameters
print("\b using the range function with start,end, and step points")
for i in range(1,10,3):
print(i)
For your convenience, we will go through the basic to the complex concepts.
The three parameters are useful to get a uniform series of numbers.
Only integers can be used with the range function.
If the start point is not mentioned, it always starts from zero.
The stop parameter is the compulsory one to use in the range function.
To make the restriction of only integers, the “int” keyword is used with the input function in a specific syntax.
You can get the table of any number with the range of any integer easily using the range function.
For loop is the best way to get the required output from the range function.
Consequently, we can say that we are not beginners and instead of learning the long theories about the basic concept, the focus of our lecture was towards the practical examples of the for loop therefore we started this lecture with the introduction and then moved towards the basics, syntax, examples, and the codes using different data types. As the specialized data type of the for loop is sequence, therefore, we had the practice of the for loop with the sequences. Using the range function with for loop gave us the interesting outputs and with the help of these examples, we learned the for loop in a better way. The upcoming lectures are interesting tooo so keep practicing and stay with us.
Data science is a rapidly growing field that is revolutionizing the way businesses and organizations operate. With the explosion of data in recent years, there is a high demand for professionals who can analyze, interpret, and make decisions based on large amounts of complex data. Pursuing a degree in data science can provide you with a variety of benefits, including high-demand job opportunities, diverse skill sets, strong problem-solving skills, interdisciplinary learning, and the ability to innovate. Some of the key benefits are explained below.
Obtaining a degree in data science is a smart career move, especially considering the high demand for qualified professionals in this rapidly growing industry. One of the most significant benefits of obtaining a degree in data science, whether online or on campus, is the increasing demand for professionals in this field. As businesses continue to generate and store vast amounts of data, there is a growing need for individuals who can analyze and interpret this data to inform decision-making.
The field of data science encompasses roles such as data scientists, data analysts, machine learning engineers, and more. All of these careers are in high demand in industries such as finance, healthcare, marketing, and more. Pursuing a bachelor of data science online can provide additional benefits, such as flexibility and convenience. Online programs allow students to access course materials and complete assignments at their own pace, making it easier to balance their studies with work, family obligations, and other commitments. Additionally, online programs can be more cost-effective than traditional on-campus programs, as they typically eliminate the need for transportation costs, room and board, and other expenses associated with attending an on-campus program.
Another significant benefit of obtaining a degree in data science is the diverse skillset that you will acquire throughout the program. Working with large amounts of data requires a wide range of skills, including programming, statistical analysis, data mining, machine learning, and more. Pursuing a degree in Data Science will allow you to develop proficiency in these essential areas, and you will learn how to use various tools and techniques to analyze data and extract insights.
Programming skills are fundamental to data science as they enable you to manipulate, clean, and transform data efficiently. You will also get to know how to code in languages such as Python, R, and SQL and how to use various libraries and frameworks to analyze and visualize data.
Statistical analysis is another critical area in data science that you will learn. You will gain expertise in probability theory, hypothesis testing, regression analysis, and more. These skills are necessary to interpret and draw insights from complex data sets.
A data science degree is a program that offers students an interdisciplinary learning experience. This field of study involves the use of data to derive insights and make informed decisions. To be successful in this field, individuals need to know various disciplines, including mathematics, computer science, and business.
As you pursue a Data Science degree, you will gain a comprehensive understanding of these fields, which will enable you to work effectively with professionals from diverse backgrounds. You will also learn to apply critical thinking skills to solve complex problems that require a multidisciplinary approach.
The interdisciplinary approach to learning in data science can also help you identify new opportunities for innovation and collaboration. By combining knowledge and skills from different fields, you can create new solutions that address challenges more effectively and efficiently.
A data science degree is a program that equips students with the ability to innovate. Data science is a dynamic and rapidly evolving field where new tools and techniques are constantly emerging. By pursuing a Data Science degree, you will develop the necessary knowledge and skills to stay current with the latest developments in the field.
This knowledge will enable you to innovate and bring new ideas to the table. In today's fast-paced business environment, the ability to innovate is critical. With a Data Science degree, you can leverage the latest technologies and techniques to solve complex problems and identify new opportunities.
Moreover, the skills you acquire during your degree will enable you to develop new solutions that improve business processes and decision-making. You will be able to analyze large volumes of data and extract valuable insights that can inform business strategies.
Innovative thinking is a crucial skill that is highly valued in the field of data science. Pursuing a degree in data science provides you with a deep understanding of various data-related concepts, techniques, and tools. This knowledge, coupled with your creativity and problem-solving abilities, enables you to develop innovative solutions to complex problems.
In data science, innovative thinking involves identifying patterns, trends, and insights others may not have noticed. You can use this information to develop new approaches to solving problems, improve existing processes, and create new products or services.
By combining data analysis with innovative thinking, you can discover new opportunities that may have been previously overlooked. For instance, you may identify potential new markets, discover patterns in customer behavior, or find new ways to improve efficiency in operations.
Innovation is vital in today's rapidly changing business landscape, and a Data Science degree equips you with the skills and knowledge necessary to stay ahead of the curve. It allows you to think outside the box, generate fresh ideas, and develop solutions that can set you apart in the job market. Ultimately, pursuing a degree in data science can help you cultivate the innovative thinking skills necessary to succeed in this dynamic field.
In conclusion, obtaining a degree in data science offers several benefits. The field of data science is in high demand, with organizations seeking professionals who can extract insights from large and complex datasets. Data science also requires a diverse skillset, including programming, statistics, machine learning, and data visualization. This makes it an interdisciplinary field where individuals with backgrounds in various fields can contribute to solving complex problems.
Data science also requires a strong problem-solving ability, which is highly valued in many industries. Individuals trained in data science can develop a unique perspective on problem-solving focused on leveraging data to drive informed decisions.
Thank you for joining us today for our in-depth Raspberry Pi programming tutorial. The previous guide covered the steps necessary to connect a fingerprint scanner to a Raspberry Pi 4. In addition, we developed a python script to complement the sensor's ability to identify fingerprints. Yet, in this guide, we'll discover how to interface a ws2812 RGB to a Raspberry Pi 4.
Bright, colorful lights are the best, and this tutorial shows you how to set up Fully Configurable WS2812B led strips to run on a Pi 4 computer as quickly and flexibly as possible. In that manner, you can have the ambiance of your home reflect your tastes.
In most cases, when people talk about a "WS2812B Strip," they mean a long piece of extensible PCB with a bunch of different RGB LED Nodes spread out and dotting all along the top. As a bonus, WS2812B strips can be addressed individually. Each RGB node can independently set its own color and brightness. The functionality of non-addressable RGB strips will be identical to that of WS2812B strips. WS2812B Strips are superior in every way, allowing for more imaginative LED light shows. It is possible to create more complex animations, stripes, and chases by individually programming the actions of each LED Node.
The "WS" in WS2812B indicates that this is the second major revision of this design; "World Semi" refers to the chip's original equipment manufacturer, "2812" to its specific part number, and "B" to its revision number. Each WS2812B LED Node contains an integrated circuit chip, as shown below.
Fully Configurable Strip LEDs now come in wide varieties. It's important to remember whether the strip operates on 5 volts or 12-volt power. To power our 5V-powered Raspberry Pi Computer, we need to use a 5V power supply. Or we'll have to install extra gear to meet the 12v Dc power specifications. LED Node densities also vary across WS2812B LED strips. Since our strip consists of WS2812B nodes soldered onto rigid PCBs, it may also be controlled by the Python script included in this article. ws2812B LED strips are the ideal LEDs to use because of the benefits above. What this manual entails is listed below.
The control mechanism implemented in this tutorial works with WS2812B LED nodes, whether they are rigidly coupled on a PCB or flexibly arranged over a long strip. No prior experience with Raspberry Pi has required, thanks to our comprehensive online raspberry pi 4 for the introduction. You should be able to follow these guidelines if you've read at least chapter 1.
| Where To Buy? | ||||
|---|---|---|---|---|
| No. | Components | Distributor | Link To Buy | |
| 1 | Jumper Wires | Amazon | Buy Now | |
| 2 | Raspberry Pi 4 | Amazon | Buy Now | |
Let's go over the protocol for these addressable LEDs so you can see how they function. Each WS2812B unit's red, green, and blue LEDs can be independently controlled to one of 256 brightness levels. Each LED module needs 24 bits of data or three groups of eight brightness bits. Here's a quick rundown of the steps involved:
The first LED in the string receives this data stream from the microcontroller, which consists of eight green bits, eight red bits, and eight blue bits.
In the case of several LEDs, the data sequence for the second LED begins with green, red, and blue information immediately after the information for the first LED. The process repeats itself until each LED is turned on.
The first LED acts as a receiver for data for all subsequent LEDs in the chain and then sends that data to the second LED without applying the same sequence.
When the original "number one" LED unit runs out of binary LED sequences, it passes the baton to the next available unit.
What follows are detailed instructions for configuring a single Raspberry Pi board to manage many individually addressable LEDs.
A pi 4
5v led strip
A DC barrel jack to 2-pin terminal block adapter.
More than 30 WS2812B strip Nodes will necessitate the usage of an external power supply. Even with highly efficient LEDs, producing brilliant light takes a lot of energy. On average, each pixel will consume 20mA, and while projecting white light at full brightness, each pixel will consume 60mA. This information shows us that 30 Pixels can consume 600mA on average and 1.8A at full brightness. As a side note, staring directly into a room with the lights set to full white causes blind spots in my vision. Because of this, I typically set the brightness of my WS2812B lights to 20%. Ensure your WS2812B strip's power source is adequate for the illumination level you intend to achieve.
In today's world, 3.3V data logic is compatible with most WS2812B LED nodes. The GPIO Pins on a Raspberry Pi have an operational voltage range of 0 to 3.3V; therefore, this works out perfectly. This surface-mounted WS2812B strip Node has seen five minor changes since its inception. Since the earlier WS2812B strip can only work on 5V Data Logic, a logical level shifter may be necessary if you're experiencing strange or intermittent issues.
We'll configure our Raspberry PI to look and act like a desktop PC because that's how most people use computers at home and because it's the most user-friendly setup for novice makers. To convert our Raspberry Pi into a desktop computer, we'll need to install a micro-SD card pre-flashed with the operating system. Then hook it up to a monitor via HDMI and a mouse/keyboard combo. Also, this is a good moment to install a small heatsink on the Raspberry Pi Board's central processing unit IC. Look at the image below to see the setup adjacent to a short WS2812B LED strip with three wires protruding from it. The WS2812B has three wires that have not yet been connected to the Raspberry Pi. WS2812B LED Strip PCBs are often marked with arrows to indicate the direction of data flow. It is a common problem in troubleshooting when this is ignored.
How to Configure Hardware for WS2812B Chains with fewer than 30 Nodes We need to plug in the 5V WS2812B Strip's three wires to the Raspberry Pi before turning the power on. Link the Raspberry Pi's 5V Power Input Pin with the Red Power Cable. Join the white wire labeled "Ground" to the Pi's Ground pin. Join the Raspberry Pi's Green Input Pin to its GPIO 18 port. It is important to remember that the Green Input Pin could be any GPIO pin as long as the appropriate adjustments are made in your Python programs. In this manual, GPIO 18 will be used for the Data Line in all scripts. The picture below shows how these three wires are joined together. This straightforward system can provide power and data transmission for a limited amount of LEDs.
Hardware Configuration for a WS2812B Strip with more than 30 Nodes in Length. However, the Pi 4 Power Pin Out is not powerful enough to power a full LED strip. It's important to know the power requirements of fully addressable WS2812B LEDs, especially when used in large quantities. 150 fully illuminated RGBW LEDs should be manageable by a high-quality 5v 4A power supply.
Following the diagram below, we will connect a 5V 4A power source via a DC barrel jack. Our WS2812B LEDs are pre-soldered with one green data wire, two red power wires, and two white ground wires. The white wire should be attached to the DC barrel jack's negative terminal using a screwdriver. Join the Red Wire to the Terminal With the Positive Screw Down. The White Connectors all link to one other, indicating a Common Ground shared by the Raspberry Pi and the power source. The two devices can't be connected without ground, which will prevent voltage fluctuations and data transmission mistakes.
Furthermore, the WS2812B Strip is no longer connected to the Pi 4 computer via a red power wire. We have found an alternative to using a Raspberry Pi to run our system. See the diagram below for details on connecting a Raspberry Pi to a string of WS2812B LEDs so that they may be controlled remotely.
There are several great best practices to keep in mind if you're planning on powering many LED strips. If you need to run more than a 5-meter roll of LEDs, I recommend consulting the adafruit documentation on the subject. It's important to think about heat and currents.
Now that everything is hooked up how you like it, you can turn on the Pi 4 System by inserting a USB-C cable.
You'll need to install a few packages if you're starting with a clean install of Raspberry Pi OS. Since this is the case, WS2812B LEDs will function properly. When you plug the Raspberry Pi into an electrical outlet and finish the initial boot-up wizard, you will be taken to the operating system's familiar desktop.
Click the black button in the upper left corner to open a new terminal window. An interactive terminal will launch. Below is a picture of this happening, with a huge red arrow indicating the pressed terminal icon.
With this terminal window, we can search for specific programs and download them from the internet. Here are the command lines you use in the terminal to install everything you need. Type | Y | to confirm installs if prompted.
sudo pip3 install rpi_ws281x
sudo pip3 install adafruit-circuitpython-neopixel
sudo python3 -m pip install --force-reinstall adafruit-blinka
You now have the software and programming packages installed on your Device to power and run WS2812B properly.
You may trigger the Raspberry Pi to turn on the associated WS2812B LED strips in various ways. To begin, I will utilize the simplest and quickest technique, which involves hooking up this Raspberry Pi to a monitor, mouse, and keyboard so that I can execute Python scripts directly to control it. Below, you'll find the best and most fun Python script to start with: | strandtest.py |. Even though it's far more involved than the rest of the Python scripts in this tutorial, we felt it was essential to include it first because it provides a comprehensive overview of the various possible patterns and lighting styles.
import time
from rpi_ws281x import *
import argparse
LED_COUNT = 30
LED_PIN = 18
LED_FREQ_HZ = 800000 # LED signal frequency in hertz (usually 800khz)
LED_DMA = 10 # DMA channel to use for generating a signal (try 10)
LED_BRIGHTNESS = 65 # Set to 0 for darkest and 255 for brightest
LED_INVERT = False # True to invert the signal (when using NPN transistor level shift)
LED_CHANNEL = 0 # set to '1' for GPIOs 13, 19, 41, 45 or 53
def colorWipe(strip, color, wait_ms=50):
"""Wipe color across display a pixel at a time."""
for i in range(strip.numPixels()):
strip.setPixelColor(i, color)
strip.show()
time.sleep(wait_ms/1000.0)
def theaterChase(strip, color, wait_ms=50, iterations=10):
"""Movie theater light style chaser animation."""
for j in range(iterations):
for q in range(3):
for i in range(0, strip.numPixels(), 3):
strip.setPixelColor(i+q, color)
strip.show()
time.sleep(wait_ms/1000.0)
for i in range(0, strip.numPixels(), 3):
strip.setPixelColor(i+q, 0)
def wheel(pos):
"""Generate rainbow colors across 0-255 positions."""
if pos < 85:
return Color(pos * 3, 255 - pos * 3, 0)
elif pos < 170:
pos -= 85
return Color(255 - pos * 3, 0, pos * 3)
else:
pos -= 170
return Color(0, pos * 3, 255 - pos * 3)
def rainbow(strip, wait_ms=20, iterations=1):
"""Draw rainbow that fades across all pixels at once."""
for j in range(256*iterations):
for i in range(strip.numPixels()):
strip.setPixelColor(i, wheel((i+j) & 255))
strip.show()
time.sleep(wait_ms/1000.0)
def rainbowCycle(strip, wait_ms=20, iterations=5):
"""Draw rainbow that uniformly distributes itself across all pixels."""
for j in range(256*iterations):
for i in range(strip.numPixels()):
strip.setPixelColor(i, wheel((int(i * 256 / strip.numPixels()) + j) & 255))
strip.show()
time.sleep(wait_ms/1000.0)
def theaterChaseRainbow(strip, wait_ms=50):
"""Rainbow movie theater light style chaser animation."""
for j in range(256):
for q in range(3):
for i in range(0, strip.numPixels(), 3):
strip.setPixelColor(i+q, wheel((i+j) % 255))
strip.show()
time.sleep(wait_ms/1000.0)
for i in range(0, strip.numPixels(), 3):
strip.setPixelColor(i+q, 0)
# Main program logic follows:
if __name__ == '__main__':
# Process arguments
parser = argparse.ArgumentParser()
parser.add_argument('-c', '--clear', action='store_true', help='clear the display on exit')
args = parser.parse_args()
# Create NeoPixel object with appropriate configuration.
strip = Adafruit_NeoPixel(LED_COUNT, LED_PIN, LED_FREQ_HZ, LED_DMA, LED_INVERT, LED_BRIGHTNESS, LED_CHANNEL)
# Intialize the library (must be called once before other functions).
strip.begin()
print ('Press Ctrl-C to quit.')
if not args.clear:
print('Use "-c" argument to clear LEDs on exit')
try:
while True:
print ('Color wipe animations.')
colorWipe(strip, Color(255, 0, 0)) # Red wipe
colorWipe(strip, Color(0, 255, 0)) # Blue wipe
colorWipe(strip, Color(0, 0, 255)) # Green wipe
print ('Theater chase animations.')
theaterChase(strip, Color(127, 127, 127)) # White theater chase
theaterChase(strip, Color(127, 0, 0)) # Red theater chase
theaterChase(strip, Color( 0, 0, 127)) # Blue theater chase
print ('Rainbow animations.')
rainbow(strip)
rainbowCycle(strip)
theaterChaseRainbow(strip)
except KeyboardInterrupt:
if args.clear:
colorWipe(strip, Color(0,0,0), 10)
Get started with Python using an IDE like Thonny IDE. You can use any Python Interpreter you like, as Thonny IDE is one of many. Thonny IDE can be accessed through the Application Menu under the Programming submenu. Then, copy the above code inside Thonny Python Editor and save it as strandtest.py on your desktop. Proceed by clicking the large green Run button. See what happens when you do that in the image below.
With that, you should see vibrant hues coming from your LED strip. If individual LEDs on your WS2812B LED Strip aren't lighting up, but the others are, open the Python script, locate the variable labeled LED COUNT, and raise its value till it's in line with the number of LEDs on your strip. The script can be saved and re-run by clicking the Run button. To accommodate the enormous quantity of WS2812B LED Strip, I set this variable to 150. In the next image, you can see a long WS2812B strip that has been wired to an external power source and is controlled by the modified Python script.
Now you can check if your Device is properly constructed and functioning with the help of the above strandtest.py script. Moreover, the resulting illumination is just breathtaking. Maker may be left wanting more, though. This is of special importance to the readability of the code, which facilitates its adaptation to specific tasks. This section will show you how to control the WS2812B strip with a few basic Python programs easily modified to suit your needs.
To get started, look at OneStripNeopixels.py, a very basic WS2812B Control Script.
import time
import board
import neopixel
#Initialise, a strips variable, provide the GPIO Data Pin
# utilized and the amount of LED Nodes on the strip and brightness (0 to 1 value)
pixels1 = neopixel.NeoPixel(board.D18, 55, brightness=1)
#Also, create an arbitrary count variable
x=0
pixels1.fill((0, 220, 0))
#LED Node 10 and the color Blue were selected
pixels1[10] = (0, 20, 255)
#Showing a different color
time.sleep(4)
#Below will loop until variable x has a value of 35
while x<35:
pixels1[x] = (255, 0, 0)
pixels1[x-5] = (255, 0, 100)
pixels1[x-10] = (0, 0, 255)
#Add 1 to the counter
x=x+1
#Add a small time pause which will translate to 'smoothly' changing color
time.sleep(0.05)
#Below section is the same process as the above loop, just in reverse
while x>-15:
pixels1[x] = (255, 0, 0)
pixels1[x+5] = (255, 0, 100)
pixels1[x+10] = (0, 255, 0)
x=x-1
time.sleep(0.05)
#Add a brief time delay to appreciate what has happened
time.sleep(4)
#Complete the script by returning all the LEDs to the off
pixels1.fill((0, 0, 0))
The Python script has been thoroughly commented on, so you should have no trouble following along. The script in the previous paragraph includes readily apparent dials and switches. You'll learn the fundamentals of making a captivating LED Pattern, including how to adjust the number of LED Nodes, the brightness of the LED strips, whether to illuminate the entire board or just a section of it and how to illuminate individual LEDs. Each Node color can be customized by entering a corresponding Red, Blue, or Green numeric value. A number can have any value between zero and 255. The term "RGB Color Code" is commonly used to describe this. While experimenting with different hues can be a lot of fun, the best method to find the precise shade you need is to use a website that lists RGB color codes. Choose any color on this site, and you'll get its corresponding RGB color code in three numbers. After you've located the three-digit color code, you can easily enter it into the Python program.
You can copy and paste the script into Thonny IDE and run it. Once you've saved the file, you can press the run button to activate the script. Below are some screenshots displaying the output.
Next is to hook up a few different LED Strips to the Pi 4 SBC and run a Python script to manage everything. Hardware-wise, I've replicated the procedure described in Hardware Configuration for Small, fewer than 30 Nodes long WS2812B, adding a second, similarly-sized WS2812B LED Strip.
I wired an additional WS2812B strip of lights up to the GPIO in the manner described below. The Raspberry Pi's other 5V Pin was connected to the red power line. The Raspberry Pi's White Ground Wire was attached to the board's second Ground Port. In this case, GPIO 21 received the green data wire. Check out the diagram of the wired components below; using two WS2812B LED strips of varying density is fine.
Using Thonny IDE as previously, run the python script titled TwoStripsNeopixels.py to control these two WS2812B Strips in a no-frills fashion. Look at this thoroughly documented Python script down here.
#include all necessary packages to get LEDs to work with Raspberry Pi
import time
import board
import neopixel
#Initialise two strips variables, provide the GPIO Data Pin
# utilized and the amount of LED Nodes and brightness (0 to 1 value)
pixels1 = neopixel.NeoPixel(board.D18, 30, brightness=1)
pixels2 = neopixel.NeoPixel(board.D21, 6, brightness=1)
#Focusing on a particular strip, use the command Fill to make it all a single color
#based on decimal code R, G, B. Number can be anything from 255 - 0. Use an RGB Colour
#Code Chart Website to quickly identify a desired fill color.
pixels1.fill((0, 255, 0))
pixels2.fill((0, 0, 255))
#Sleep for one second, and then code repeats for different color combinations. Light changes
#Could happen instead in response to certain buttons being pressed or due to threshold values
time.sleep(1.5)
pixels1.fill((200, 200, 0))
pixels2.fill((0, 200, 200))
time.sleep(1.5)
pixels1.fill((50, 70, 215))
pixels2.fill((215, 50, 70))
time.sleep(1.5)
pixels1.fill((0, 0, 0))
pixels2.fill((0, 0, 0))
Note that a Pi 4Computer has four Data Wire locations that can control individual WS2812B LED Strips, provided the corresponding Python script is updated correctly. The pinouts are numbered as follows: GPIO18, GPIO21, GPIO12, and GPIO10. With some tweaking and development of this technique, you can use a single Raspberry Pi as a standalone controller for four individually addressable WS2812B strips.
Ensure the right number of LED Nodes has been assigned to both LED WS2812B Strips before running the script. Once the script is ready to be executed, click the Thonny IDE's large green Run button. Both strands will suddenly come to life, each filled with a unique color. In the picture below, you can see this in action.
In this tutorial, we looked at connecting a WS2812B led strip to a Raspberry Pi. We also programmed the LEDs to blink in various patterns and colors using Python. You may now explore with your raspberry pi and these led strips to create patterns or whatever you like. Next, we'll look at connecting a Pi 4 to a sharp infrared distance measurement sensor.
Hello learners! Welcome to the next episode of the arrays, in which we are moving towards the details of the arrays at an advanced level. In the previous lecture, we covered the introductions and fundamentals of arrays, dimensional arrays, and array operations. One must know that the working of the arrays does not end with simple operations, and there is a lot to learn about them. Arrays and their types are important topics in programming, and if we talk about Python, the working and concepts of the array in Python are relatively simple and more effective. The details of the advanced types of arrays will prove this statement. We have a lot of data to share with you, and for this reason, we have arranged this lecture. It is important to understand the reasons behind the reading of this lecture.
What are two-dimensional arrays, and how can we perform them in a Jupyter notebook?
How can we access all the elements of the two-dimensional arrays?
Can we insert the elements in the two-dimensional arrays?
How do we update our 2D array?
Is the appending process easy in the 2D arrays in Python?
Explain three-dimensional arrays and provide an example of how the array is updated.
All of these are important interview questions, and you will learn the concept through its practical implementation, so stay with us till the end of this lecture to get all the answers.
We all know a lot about one-dimensional arrays and have seen these concepts at different levels. In this type, we are dealing with the arrays at an advanced level, and to understand them, we will work on the Jupyter notebook. The second type of array is a little bit different, and we can say it is twice as difficult as the one discussed before. We all know the concept of dimensions from physics classes, and these concepts are also true for arrays. These are also referred to as "multi-dimensional arrays," and we define them as:
“The 2-D arrays are the type of arrays that are shown by two indices, and these contain rows and columns to save the data in the form of matrices.”
As you can guess, these are comparatively more complex than the one-dimensional arrays, and storing the data in them is more useful and has many applications in real life. While performing the example of a 2D array, we are going to use the simpler way where the user just has to mention the numbers of rows and columns and an array is ready.
array-name = [ [d1, d2, .... ,dn], [e1, e2, .... ,en] ]
Here,
d1,d2,...,dn=number of elements in the first dimension
e1,e2,...,en=number of elements in the second dimension
The numbers of the elements vary from zero to infinity. For more detail, have a look at the example given next:
#Initializing the two-dimensional array
array_input = [ [10.9,78.9,111.90] ,[8.0,771.2,2.0] ]
#showing the elements of each dimension separately
print("The elements in the first dimension = " ,array_input[0])
print("The elements in the first dimension = " ,array_input[1])
So you can see that the initializing of the array with the floating elements is done in the first step. Here, the point to notice is the usage of square brackets, and you have to remember that no other type of array is used in this case.
In the previous case, you have seen that if we wanted two or more elements as output, there was a need for more than one print function. Yet, there are also cases where the whole elements of an array are required on the screen. For this, the programmers use different types of iterations according to the requirements and get the results. We have seen the working of the iterations many times in this course and therefore, there is no need to explain why we use it. Arrays are one of the best examples to check the working of the iterations. In all the examples of the arrays, you will see the use of for loop in the nested form because we are dealing with two-dimensional arrays.
One must be wondering how we can add more elements to the two-dimensional arrays because of the matrix-type arrangement of the lament. For this, the method is simple, and by discussing it, we will learn the “input” method of Python. Have a look at the code given next, and we will discuss the details in just a bit.
#importing the array from the Python
import array as twoDArray
#declaring our array with two dimensions of the order 2 by 2
twoDArray = [[2,2,2,2,2,2,2], [6,6]]
print("Array before insertion of elements: ", twoDArray)
#Inserting the elements in the matrix at position three
twoDArray.insert(3, [4,7,4,2,9])
print("Array after insertion of elements: ")
#Using nested for loop to inset the elements one after the other at the required position
for x in twoDArray:
for y in x:
print(y,end = " ")
print()
The following points are to be discussed according to this concept:
Importing the array makes the code easy and effective.
The two-dimensional array is nothing but the arrangement of elements in the form of rows and columns.
The number of rows and columns is not restricted to each other, that is, there is no restriction on using the square array all the time, and the number of elements in rows and columns may be different from each other.
The square brackets are used in the two-dimensional arrays in every case, whether it is the outermost bracket or dimensional bracket.
Special functions such as insert, delete, etc. can be used by using the dot operator with the name of the array.
To insert the elements in the two-dimensional array, a nested for loop is efficient where two loops are being used. The syntax is important in this case.
Other rules of the code are discussed in different lectures in this course.
The next case that we are going to discuss is the updating of the elements in the arrays. Think about the situation when you first declare the array and work with it, but after some time, you have to change some of the elements of the arrays. In such cases, the insertion and deletion operations that must be done are time-consuming. The best way to do this is to update the elements directly. The reason why I mention this detail is that arrays are unchangeable data types in other programming languages such as C++, and once declared, the arrays can not be altered in such languages. Yet, Python gives us the ease to update, delete, insert, and change the arrays in the programs. We know programming is a vast procedure and there are several ways to do the same task, but for you, we have picked the simplest and most interesting way to do so that is given in the code next:
#Importing the array
import array as Updation
#Declaring a two-dimensional array
Updation = [[22,56,4,1], [2,4,6,8,10]]
print("Array before Updation of elements: ", Updation)
#updating the elements in the second array and the third element of the first array
Updation[1] = [44,89,2,0]
Updation[0][3] = 5
print("Array after update of elements: ")
#using nested for loop to print the array
for x in Updation:
for y in x:
print(y,end = " ")
We are now able to understand such codes; therefore, there is no need for long descriptions. But, the point here to notice is, in the same code, merely by declaring the elements at certain positions, the array can be updated and the previous values are then ignored.
In the previous lecture, the element at the end of the one-dimensional array was appended easily. Yet, you must think that more detail is required for the appending of the data because it has to be mentioned where the exact place is where you want to append the data. So, if you remember the previous lecture then you will find it different to append this type of array.
#importing the array
import array as myArray
#initializing our array
myArray = [[1.4,66.90,234.0], [009.6,127.8,34.0,11.34], [0,2]]
print("Elements of my array = ", myArray)
#Using the length operator to check the length before appending the elements
length=len(myArray)
print("Length of the array before appending: ", length)
#The process of appending
myArray.append([7.9,334.90,2303])
#calculating and printing the length after appending elements
length=len(myArray)
print("Length of the array after appending: ", length)
#printing the results after appending
for x in myArray:
for y in x:
print(y,end = " ")
print()
The difference is clear; the number of elements can be easily compared with the help of the length function. We have used the length function many times in this course, and here you can see a better example of how to use it.
The three-dimensional array is the most complex form of the array discussed so far, and usually, at this level, the learner does not go into the details of the three-dimensional arrays to avoid complexity. The 2D array has many interesting applications and has the ability to store a lot of data in a cleaner way; therefore, 3D arrays are not used much for learning purposes, but if we talk about complex applications such as gaming and other fields, the 3D arrays have a great scope.
The form of the 3D array can be understood by keeping the matrix of the order 3x3 in mind. Here is a little information about the initialization of the three-dimensional arrays in the Jupyter notebook.
#initializing my three-dimensional array
ThreeD=[[[22.5,[67.9],[44.4]],[5],[23.8]],[[12,[123],[893]],[0],[78],[126]],[[70],[11]]]
print("The three dimensional array = ", ThreeD)
#Simply updates the elements by mentioning the locations and values.
ThreeD[0][0][0] =11
ThreeD[1][0][0] =21
ThreeD[0][0][1] =111
#Printing the results
print("After updating the elements the array = " ,ThreeD)
Hence, this picture gives us information about the shape and form of the three-dimensional arrays. Do not think that 3D arrays have the form of a 3-by-3 matrix. I suggest you take a deep look at the brackets of the array that we have mentioned here. The complexity of the three-dimensional array is much greater than in previous cases. To make it simple, we have used the single element in the single brackets, but there are more options for the same work that will be unnecessary to learn right now.
Another thing to be mentioned here is that, for simple operations such as displaying and updating the elements, there is no need to import the array every time. Yet, we have used it to display the proper professional coding of the array. We are not talking about the three-dimensional arrays in more detail because they are very difficult to understand and because there are some other options that work better than the three-dimensional arrays. You will learn it in detail in the next lectures.
Therefore, we can say that we have learned a lot about the advanced level of arrays in Python which are two-dimensional arrays and three-dimensional arrays. It is interesting to note that dealing with arrays is much easier in Python than in any other programming language. Therefore, we always say that Python is interesting and easy to learn. The topic ends here, but the detail of data type is not limited to just the types of array. You have to learn a lot about iit,and we are here to share every single and necessary detail in a simple way. So, stay with us in this learning phase.
Hello Python programmers! Welcome to the engineering projects where you will find the best learning data in a precise way. We are dealing with Python nowadays, and today, the topic of discussion is the arrays in the language. We have seen different data types in Python and discussed a lot about them in detail till now. In the previous lecture, we saw the details of the procedures in dictionaries. There are certain ways to store the data in the different types of sequences, and we have highlighted a lot about almost all of them. It is time to discuss the arrays, but before this, it is better to understand the objectives of this lecture:
Introduction to arrays
Difference between contiguous and non-contiguous memory locations
One-dimensional arrays
Functions in arrays
If you are from a programming background, then you have surely heard the name "arrays" and used them in your practice. Yet, if you are a beginner, you must know that arrays are present in almost all types of high-level programming languages. The array is also the way to organize and store the data in a sequential way, but it has some very basic characteristics, most of which are similar to those of other data types, but some are a little bit different, and we will work on both of these types. But before that, let's take a look at the basic definitions of an array:
“An array is a collection of items that are stored in contiguous memory locations. The idea is to group together items of the same type.”
This makes calculating the position of each element easier by simply adding an offset to a base value, i.e., the memory location of the array's first element. These are used to store a gigantic amount of data in different departments and offices, and because it is an old technique, people prefer it to other types such as sets, lists, and dictionaries.
When working with arrays, you will always notice the term "contiguous," and it makes sense because it is the best word to describe the structure of the array. It is the finite collection of data in which the elements are arranged strictly one after the other in the successive locations of memory, and in this way, a contiguous structure is obtained just like a ladder in a horizontal way. If you think it is all about knowing about the contiguous memory locations, then you are wrong. But, it is better to understand the concept by comparing it with the help of the opposite of it, that is the non-contiguous memory places.
Sr # |
Feature |
Contiguous Memory Allocation |
Non-Contiguous Memory Allocation |
1 |
Definition |
Contiguous memory locations are the type of allocation that allocates a continuous block of memory without skipping any places. |
Non-contiguous memory allocation, on the other hand, is the type in which memory is not continuous but separate blocks of memory are allocated regardless of how little space exists between them. |
2 |
Complexity |
The control of the operating system is easy in it because the memory can be smoothly be accessed. |
In this case, controlling the OS is comparatively difficult. |
3 |
Execution time |
The execution time is faster as compared to the other type, and it makes sense because the compiler does not have to sense the gap and then jump according to the length of the gap. |
In this case, the execution time is longer than in the first case because the compiler jumps from one memory location to the other. The time is determined by the gaps between the allocated memory. |
4 |
Overhead |
Because there are fewer address translations when dealing with contiguous memory allocation, there is less overhead. |
Because the address translation is greater in this case, we have more overhead. |
5 |
Special Features |
The contiguous memory allocation contains single-partition allocation as well as multi-partition allocation. |
When dealing with non-contiguous memory allocation, paging and segmentation are observed. |
6 |
Type of Fragmentation |
These include both internal and external fragmentation in the case of contiguous memory allocation. |
The internal fragmentation does not occur in this case, and we get only external fragmentation. |
7 |
Swap-in process |
It is noted that the swap-in process can only be arranged in the space that was originally allocated. |
If we talk about the non-contiguous memory allocation, the swap-in process is arranged in any memory allocation, so we get versatility in this case. |
8 |
Wastage of memory |
In this case, the wasted memory varies according to the array we are using. |
It is an advantage of this type of allocation that no memory is wasted in this case. |
9 |
Types |
There are only two types of contiguous memory allocation:
The hint for this point is also given in another feature. |
We observe five types in this case that are mentioned below:
All of this is unnecessary in our case; thus, do not go into detail about this type of situation. |
This is the distinguishing feature of arrays in Python when compared to other programming languages. Arrays, like many other functions and data types, are pre-defined in Python for the convenience of programmers. Because arrays are very general data types that programmers frequently use, it is simple to declare and import arrays in the same line and then begin working with the arrays. There are several ways to use arrays in Python, one of which is to import the arrays. Have a look at the details of this process:
There are different steps that are to be followed when dealing with the arrays in Python, and these are mentioned here:
Import the arrays.
Declare the name.
Use the array in different operations.
Hence using these steps, the arrays are used in different ways and it is interesting to notice that the declaration and the usage of an array are very different in Python as compared to other higher-level programming languages such as C++, C#, etc.
To understand well, let us see all these steps in action, but I want to discuss the type of the arrays with you while performing all these steps so that we may understand both these concepts one after the other.
Here is the point of the array that makes it different from the dictionaries and sets we have mentioned before. The arrays can be made in three ways:
One-dimensional array
Two-dimensional array
Three-dimensional array
Now it's the choice of the programmer according to the requirement, which type of array is he or she using. The details of each of them will be shared with you in just a bit, but before that, open your Jupyter notebook so that we can apply these arrays practically side by side.
Go to the search area of the window and get the Jupyter notebook there.
A screen will appear in front of you, and you have to go to the drop-down menu that is present on the right side of the screen.
Choose python there and wait for the new tab to open on your browser.
Click on the new cell location and start coding.
The most basic and commonly used array is one, and it does not require much effort for you to understand its concept. The very basic structure of the array that we see in the examples and discussion The elements are arranged one after the other, and the index starts at the first place where the zero number is assigned to that location. All the elements are linearly arranged, and it is the simplest form of array that is easy to create and access. In this way, the programmer gets the collection of the same data type in a linear format. The array is then stored in a variable to be used in different ways.
#importing the arrays from the Python library
import array as myArray
result = myArray.array('i', [22,68,123,90,49,167,66,129])
# accessing elements of array and printing it
print("Accessing the first element ", result[0])
print("Accessing the fourth element ", result[3])
The following output is observed as a result:
Hence, the single elements can be accessed in this way. Have you noticed that in the array, we have mentioned the “i” before, and after that, a list is being used? It has a very special reason, and you can check this by deleting the “i” in the code. You will observe that the compiler is throwing an error about the declaration of the Unicode character. Always remember that if the programmer is using the import array method in Python, there is a rule in Python for using arrays that the first argument of the array is always a Unicode character.
Here comes the reason why we are importing the arrays into Python. The primary reason is, it has multiple functions that make the work super easy, and the programmers do not have to write the codes again and again. I am just sharing the very basic and common functions. So let’s jump to the codes:
Take the example in your mind that when you are dealing with a gigantic amount of data at the same array and it becomes tedious to search for the frequency of the particular item. In such cases, when the detail of the element appearing in the array is required, the count function is used. The working of this function can be understood with this example:
#Declaring our array of strings
import array as myArray
result = myArray.array('i', [22,68,123,90,49,34,67,22,90,33,7,11,8,44,11,77,23,90,28,541,490,299,611,20,561,112,3,88,167,66,129])
#Using the count function to get frequency
print(result.count(90))
So, when we check the frequency of the number 90, we get the following output:
Hence, we can easily conclude that in our array, the integer 90 appears three times.
The next function that is to be tested is the append function. For this, we add a new element at the end of the array, and doing this is very simple, as you can see in the code given next:
#Declaring our array of integers
import array as myArray
result = myArray.array('i', [22,68,123,90,49,34,67,22,90,33,7,11,8,44,
11,77,23,90,28,541,490,299,611,20,561,112,3,88,167,66,129])
#appending a new 90 at the end of array
result.append(90)
print(result)
The next function is reverse(), and as you can guess, the reverse of the array can be obtained with the help of a short command that we are going to test in the code next:
#Declaring our array of strings
import array as myArray
result = myArray.array('i', [22,68,123,90,49,34,67,22,90,33,7,11,8,44,
11,77,23,90,28,541,490,299,611,20,561,112,3,88,167,66,129])
result.reverse()
print(result)
As you can see, the order of all the elements is reversed in such a way that the first element is the last and vice versa.
Consequently, in this lecture, we have seen the details of arrays in a different way than when the introduction was done at the start. After that, we have seen what the workings of the contiguous memory location are and how it is different from the other types of contiguous memory locations. Different functions were also discussed in this regard, and more will be discussed in the next lecture.
Hello peeps! Welcome to the new episode of the Python tutorial. We have been working with different types of data collection in Python, and it is amazing to see that there are several ways to store and retrieve data. In the previous lecture, our focus was on the basics of dictionaries. We observed that there are many important topics in the dictionaries, and we must know all of them to make our base of concepts solid. For this, we are now dealing with the dictionaries in different ways, and this tutorial is going to be very interesting because we will pay more heed to the practical work and, by choosing a few cases in our codes, we will apply multiple operations to them. So have the highlights of today’s learning, and then we will move forward with the concepts.
What are nested dictionaries, and how do we use them?
How do you access the elements in the nested dictionary?
Tell us the procedure to add and delete elements from the dictionary.
Can we modify the elements of the dictionary? If yes, then how can we do so?
What is the membership test, and what is the procedure to use it in the dictionary?
Write the simple example in which the iteration is used with the dictionary.
In the previous lecture, we saw simple dictionaries and applied their functions to them. In the present lecture, the details of the dictionaries will be discussed in detail. These functions are not new to us but have been learned while dealing with sets and lists. Yet, the working and the results of every function are different with different types of data, and therefore, we are using the predefined functions again but with a twist. In the previous lecture, we saw the nested dictionary in an example but have not mentioned the details because we were discussing the list in dictionaries and it was not suitable to discuss it at that moment. Yet, have a look at the definition of a nested dictionary:
“A nested dictionary is a type of dictionary in Python that contains more than one dictionary separated by commas in it with different indexes, and each dictionary has a specific number according to its order.”
Accessing the data is a little bit more difficult in the nested dictionaries than in the simpler ones because the index is so important. The dictionaries are then divided with the help of commas between them. Open your Jupyter notebook by following these steps:
Go to the search bar on your PC.
Search for the Jupyter notebook.
Now go to the drop-down menu and choose Python there.
Wait for the new local host to be opened in your browser.
Go to the new cell and start coding.
Copy this code and paste it into the cell. By pushing the run button, you will get the perfect nested dictionary.
Do you know the meaning of our statement that accessing the data from a nested dictionary is a little bit different? It is because we need to type more of the data, and therefore, it is important to mention all the information accurately, as with all types of data, and this becomes tricky for non-programmers.
#Declaring the nested dictionary containing the information of the books in a library
bookData = {1: {'subjectName': 'Physic', 'coverColor': 'red', 'Pages': '125'},
2: {'subjectName': 'Chemistry', 'coverColor': 'blue', 'Pages': '234'},
3: { 'subjectName': 'Biology', 'coverColor': 'green and blue', 'Pages': '564'}}
#Printing the required value
print("Your required data = ", bookData[2]['coverColor'] )
So, as you can see, the real use of a nested dictionary is to get more readable and clean data every time. These are the advantages of the nested dictionary it is more practical, and a large amount of data can be stored and accessed easily.
It is the plus point of the dictionary that programmers can easily add the element in the nested dictionary by using some simple steps. The point here is to e discussed is to show you that the concept of an empty dictionary is present in Python. Many other data types do not have this characteristic. Hence, the addition of a new element becomes easy while using the dictionary. Have a look at the output of the code and after that, we will discuss the points about it.
#Declaring the nested dictionary containing the information of the books in a library
bookData = {1: {'subjectName': 'Physic', 'coverColor': 'red', 'Pages': 12},
2: {'subjectName': 'Chemistry', 'coverColor': 'blue', 'Pages': 234},
3: { 'subjectName': 'Biology', 'coverColor': 'green and blue', 'Pages': 564}}
print("Dictionary before modification = ",bookData )
print()
#Making the room for the new element by creating the empty dictionary
bookData[4]={}
#inserting elements in the next space
bookData[4]['subjectName']= 'English'
bookData[4]['coverColor']= 'yellow'
bookData[4]['Pages']= 611
print("The modified dictionary= ", bookData)
We can conclude the following points from the data given above:
The addition of the new dictionary to the existing nested dictionary is easy.
There is a need for a blank element so that we may fill in the required items.
The programmer in the code has declared the number of the dictionary and not the index, therefore, the data is not started with a zero and instead, the numbers of our choice are used. The programmer may name its dictionary anything no matter if it is the number of the alphabet.
Let us discuss the case in which the programmer wants to delete the whole dictionary from the nested collection for some reason. For this, the procedure is not too long and the simple delete command is used for it. For better elaboration, we are using the same example and deleting the second dictionary from our list.
#Declaring the nested dictionary containing the information of the books in a library
bookData = {1: {'subjectName': 'Physic', 'coverColor': 'red', 'Pages': 12},
2: {'subjectName': 'Chemistry', 'coverColor': 'blue', 'Pages': 234},
3: { 'subjectName': 'Biology', 'coverColor': 'green and blue', 'Pages': 564}}
print("Dictionary before modification = ",bookData )
print()
#Deleting the 2nd dictionary
del bookData[2]
print("The modified dictionary= ", bookData
Here, the question arises if the single element is to be deleted only, what will be the code? There are only minor changes in the code given above, and only the particular element of the mentioned dictionary will be deleted.
#Declaring the nested dictionary containing the information of the books in a library
bookData = {1: {'subjectName': 'Physic', 'coverColor': 'red', 'Pages': 12},
2: {'subjectName': 'Chemistry', 'coverColor': 'blue', 'Pages': 234},
3: { 'subjectName': 'Biology', 'coverColor': 'green and blue', 'Pages': 564}}
print("Dictionary before modification = ",bookData )
print()
#Deleting the specific elements from the dictionary
del bookData[2]['coverColor']
del bookData[3]['subjectName']
print("The modified dictionary= ", bookData)
The next step is to learn about the modification process of the dictionary, and for that, we are choosing another example because it is boring to check the conditions from the same example all the time. For the sake of simplicity, we are using the simple dictionary instead of the nested type of the dictionary.
#Declaring the initial data of the staff
staffInfo = {"2C32": "HR", "2C34": "Chemist", "2C20": "Doctor"}
print("Initial Staff Information: ", staffInfo)
#Changing the staff information
staffInfo["2C32"] = "Compounder"
#Printing the results
print("Updated Staff Information: ", staffInfo)
Hence, in this way, we do not have to first delete and then add the new element in its place; simply changing the element is enough. The new value is masked over the previous one, and in this way, the task becomes easy.
Until now, we have seen some simple and short examples so that the concepts may be easily understood. Yet you must know that in real-life applications, dictionaries are so large that it becomes difficult to notice the existence of specific elements in them. For such cases, it is important to learn the command to check the availability.
# Membership Test for our new dictionary
AvailableFood = {1: "chicken", 2: "beef", 3: "barbeque", 4: "burger", 5: "soup",
6: "salad", 7: "cake", 8: "lasagna", 9: "pizza", 10: "pie",11: "sandwiches",
12: "pasta", 13: "mushrooms", 14: "sausage", 15: "ice cream", 16: "cola", 17: "cupcakes",
18: "chocolate", 19: "biryani", 20: "golgappy", 21: "bread", 22: "jam", 23: "eggs" }
#Checking the availability by using just the key
print(6 in AvailableFood)
#checking if the certain key is "not" available
print(18 not in AvailableFood)
#Using a false value to check the behaviour of the keyword
print(49 in AvailableFood)
If we go into the details of this code, we may get the idea that:
Dictionaries can be used to store a massive amount of data.
The addition of the data is so simple and uncomplicated, and we can access any element easily.
The keys are useful to get the data easily without any complexity in typing in such cases if we use the integers as keys.
The “in” function searches for the required elements of the user and gives the result about the availability of the element.
The “not in” function is totally opposite from the former case, and the programmer can use it to check whether the specific element is absent or not.
The third case is interesting, we simply put the value to check how the “in” function responds when the element is not present in the dictionary, and the result was as expected.
The iteration process is fascinating, and we always try to provide you with examples that you will use in the practical implementation over and over again. The iterations are an important concept, and you will learn them in detail in the coming sessions, but we believe that, for now, you have an idea of what they are and how the programmers use them in their codes. It is time to check what the dictionary will do if we use it in the for loop.
# Membership Test for our new dictionary
AvailableFood = {1: "chicken", 2: "beef", 3: "barbeque", 4: "burger", 5: "soup",
6: "salad", 7: "cake", 8: "lasagna", 9: "pizza", 10: "pie",11: "sandwiches",
12: "pasta", 13: "mushrooms", 14: "sausage", 15: "ice cream", 16: "cola", 17: "cupcakes",
18: "chocolate", 19: "biryani", 20: "golgappy", 21: "bread", 22: "jam", 23: "eggs" }
#using the for loop with the "in" keyword to get the list of each and every food item
for element in AvailableFood:
print(AvailableFood[element])
Hence, all the elements are printed one after the other in a new line, and the programmers can simply get the available food items by using a simple command.
For more practice, I want to check the behaviour of this loop when I use it with the nested dictionary:
#Declaring the nested dictionary containing the information of the books in a library
bookData = {1: {'subjectName': 'Physic', 'coverColor': 'red', 'Pages': 12},
2: {'subjectName': 'Chemistry', 'coverColor': 'blue', 'Pages': 234},
3: { 'subjectName': 'Biology', 'coverColor': 'green and blue', 'Pages': 564}}
print("Elements of the dictionaries = ",bookData )
print()
#printing All the dictionaries using iteration.
for myBooks in bookData:
print("Elements of single dictionary using the for loop = ", bookData[myBooks])
The results of the code given above are clean and more understandable:
Hence, the use of iterations makes our output uncomplicated and ordered. So it was all about the dictionary in this episode of the Python programming language. It was amazing to see the different examples, and all of them were related to the dictionaries. The usage of the dictionary in Python is important to understand; therefore, we used the Jupyter notebook to access, add, delete, and modify the elements of nested dictionaries and simple dictionaries with the help of examples. Moreover, the membership test was also interesting to learn and easy. In the end, the iterations made our work easy, and we got a cleaner output with the help of the iterations. We hope it was an attractive way to learn the dictionaries and stay with us for more concepts of Python. Happy learning to all of you.
Hello students! Welcome to the new Python tutorial, where we are learning a lot about this programming language by applying the codes in a Jupyter notebook. It is interesting to see how simple codes with easy syntax can be useful to store, retrieve, and use data in different ways. Many things in Python are so unadorned and pre-defined that programmers may use them in a productive way without any issue.
In the previous lecture, we have seen the details of the sets and how different types of mathematical operations are used to get the required results. We have seen many codes, the examples of which were taken from day-to-day life. In the present lecture, the mission is to learn a new topic that is related to the concepts of previous lectures. Yet, it is important to have a glance at the points that will be discussed in detail here:
Introduction to the dictionaries in the python programming language.
Why do we need dictionaries if we have different ways to store the data?
How can we use dictionaries in Jupyter notebook?
How do you define the concept of keys in dictionaries?
What are some characteristics that make the dictionaries different from others?
How do you justify that using the list with dictionaries makes the working better?
These points are the important interview questions and all of these will be crystal clear in your mind when we will go deep into these concepts one after the other. So stay in this lecture till the end and we will discuss the basic concept today.
To understand the topic, the first question that arises in the mind is what actually constitutes a dictionary and why it is important to understand this concept. An interesting piece of information to share here is that dictionaries are not new concepts; these were defined in the older versions of Python as well, but the difference is that in the older versions, from Python 3.6 onward, dictionaries were considered unordered, and if we talk about the current introduction, we will get the following lines:
"In Python 3.6 and later, a Python dictionary is an ordered collection of data that stores data in the form of pairs in keys or values."
The word “ordered” is not new to us and from the above information, we can understand that in the older versions of Python dictionaries when displayed in the output, does not have the proper indexing and the order of the element was unpredictable but when talking about the updated version (that we are using during this tutorial) the order of the elements in the dictionaries is well defined and the elements will be arranged in the same manner always that is defined by the programmer. Here it is important to notice that usually, the students are using the updated version of Python and there is no need to mention the older versions but the reason to mention this is, the older versions are preferred by the users that have older personal computers or because of any other reason, if they are using the previous versions, then they will find the dictionaries a little bit different from this tutorial.
We have been working with the data types in Python that all are used to have the collection of data and the question here is why we need another entity that can store the data if we have lists, sets, and others. The answer here is simply because the way to store the data is different for all of these and as the topic of discussion today is dictionaries, you must know that it uses the key values to store the data and therefore, it becomes uncomplicated to store the data using the key value mapping format. The most common advantage is, the retrieval of data from the dictionary becomes super easy with the help of these key values. If we talk about the complexity of the dictionaries, we will get the following data:
The best case of a dictionary has O(1) complexity.
The worst case of a dictionary has the O(n) complexity.
Now, that you understand the basics of dictionaries, to make the discussion clear, examples are being used in the Jupyter notebook. We have been using it in our tutorial, and therefore, we know that we simply have to start the software and get the new tab in the browser by clicking on the “new” dialogue box and clicking on “Python 3."
Once you get the worksheet now it's time to get used to all the codes that will clarify the concepts in a better way. So let’s start learning the concept and then simply use all the learning in our codes. This will be easy to understand because we have been working with such types of codes in this whole course but the difference here is the key of the dictionary.
You must know that dictionaries are declared by using the curly brackets in Python and if you have seen our previous tutorial, you must have the idea that the same representation was used in the sets then how can the compiler differentiate between these two and what is the reason to introduce the concept of dictionary in Python? Well, as we move towards the complex problems, we get the idea that simply storing the data is not enough, there is a need of providing the reference of the data and this happens when we use the keys in dictionaries.
“A key in Python dictionary is the specific and unique value assigned to each element and that has the immutable data type.”
The role of keys in the dictionaries will be clear by using the output of the code given next:
#declaring the dictionaries containing the grocery items
GroceryItems={"lettuce":4, "onion":34,"pepper":8,"plum":12, "frozen fruits":22}
print(GroceryItems)
Hence, the keys add more details to the dictionaries, and the data is stored in a better manner while being used in dictionaries. The usage of the keys is still ambiguous in the mind, hence, we are using different examples to express it well. There are different ways to use the dictionaries, and these procedures are given next:
#declaring the dictionaries containing the grocery items
GroceryItems={"lettuce":4, "onion":34,"pepper":8,"plum":12, "frozen fruits":22}
print(GroceryItems)
#retriving the data using the concept of keys in a dictionary
print("The required data = ", GroceryItems["pepper"])
Hence, the data stored in the key can be used easily to retrieve the data. In the example given above, when the person wants to get the number of groceries they want with the help of items.
We have focused on the examples, but before going into the details of them, you must know some important points about the dictionaries.
The dictionaries are declared with the help of curly brackets.
The keys are used with the elements and to declare them, the colon is used along with each element.
The value of the keys can be obtained by mentioning the element.
The dictionaries are ordered and every time when the same dictionary is declared, we get the element as same as that was mentioned in the code.
The usage of any data type is allowed in the dictionaries, and therefore, the working of a large amount of data is possible in the dictionaries.
Same as the sets, duplicate elements in the dictionaries are not possible. It means when the element is repeating in the code, the compiler automatically ignores the second third, or any type of repeating of the same element and therefore, the repetition is not allowed in dictionaries.
Let us now look at some examples of dictionaries where we will use our Python concepts and some functions to interact with the dictionaries.
We know about the details of lists in the Python programming language, and now we want to connect things together so that we may understand why the students had to learn a lot about lists. Python provides uncomplicated ways to use different functions and concepts and get useful results. In the Jupyter Notebook, we are now inserting the list into our dictionaries in two ways, and in this way, the concepts of lists will also refresh our minds.
During discussion about some important characteristics of dictionaries, it was mentioned that any data type can be inserted into the dictionaries, and this point will be proved with the help of the following code:
#declaring the dictionary of tooth brush
toothBrush = {
"Name of Item": "toothbrush",
"electric": False,
"price": 60,
"available colours": ["red", "white", "blue"]
}
print("Features of tooth brush in detail: ",toothBrush)
print("Price of the tooth brush= ", toothBrush["price"])
When we input this code in the new cell of our local host, after pushing the run button, the following results can be obtained:
Hence, it is proved that any data type in Python can be inserted into the dictionary, and this characteristic gives the programmers the independence to use the collection of data and relate it to a single item in the dictionary. In the example we have just seen, there were multiple options for the same brush about its colours, and hence, in such cases, the programmers use dictionaries to get the required results.
Here comes a different kind of concept that we have not learned in this tutorial until now. The list can also have the dictionaries as the element and if you are wondering why the programmers use them then you must know, the characteristics of the data types matter, and each data type has its own speciality therefore, the combination of both these data types in different ways gives us the variety of uses.
#Create a list of dictionaries that represent the prices of different items
#along with their serial number in the grocery store.
myStoreItems = [{345: 'chicken', 567: 'eggs',
561: 'beef', 879: 'mutton'},
{348: 'milk', 670: 'butter',
127: 'bread', 445: 'tea bags'},
{237: 'chocolate spread', 381: 'jam',
890: 'sauce', 340: 'sandwich'}]
print(myStoreItems)
#accessing the data from the first dictionary
print("The required item is ",myStoreItems[0][561])
#accessing the data from the second dictionary
print("The required item is ",myStoreItems[1][127])
#accessing the data from the second dictionary
print("The required item is ",myStoreItems[2][340])
In this way, we can extract the following concept from this code:
The dictionaries can be used in the lists.
There is the possibility of using different dictionaries in the same code.
The data can be accessed from any dictionary by using the index of the data.
To get the exact element, the programmers have to write the index of the element.
For using the right indexing method, first, we have to mention the dictionary number and then the key of the element.
It's a reminder that indexing starts at 0.
It becomes easy to manage the data with the keys and more data can be stored in a single dictionary in a more manageable way.
The declaration of the dictionaries resembles the sets and we see many features of these two concepts that resemble each other.
In this lecture, we started our discussion with the introduction of dictionaries. The list has many informative features, and the combination of dictionaries with the list makes many useful tasks easy to complete without facing any issues because of the smooth process. The user simply has to feed the required data, and at the appropriate time, the data can be retrieved easily. So, that was all for today. Dictionaries have applications in different ways, and therefore, it is not possible to provide students with all the necessary information in a single lecture. Therefore, in the second part, we will discuss more details about dictionaries and learn a lot through examples.
Hey people! Welcome to another tutorial on Python programming. We hope you are doing great in Python. Python is one of the most popular languages around the globe, and it is not surprising that you are interested in learning about the comparatively complex concepts of Python. In the previous class, our focus was to learn the basics of sets, and we saw the properties of sets in detail with the help of coding examples. We found it useful in many general cases, and in the present lecture, our interest is in the built-in functions that can be used with the sets. Still, before going deep into the topic, it is better to have a glance at the following headings:
What are the built-in functions?
How do we perform the all() function with examples?
What is the difference between any() and all()?
What are the parameters of sorted()?
From the beginning of this course, we have been using the built-in functions for different purposes, but here, the main idea must be cleared, so for the purpose of revision, have a look at the basic definition of these functions:
"Built-in functions are the pieces of code that have a particular result all the time and are pre-defined in the programming languages so that the programmer does not have to type the same code but simply put the values in the functions and get the required output as expected with minimum effort."
For a better understanding of the sets and the practice of these in codes, the best way is to use the built-in functions so that whenever you are coding these built-in functions arise instantly into your mind and the effort to code the same line again and again in different programs. There are certain types of built-in functions, the details of which were covered in the previous lecture, so for now, we are trying to introduce the new functions and repeat just the most common ones with the sets.
The first function of discussed by us is very interesting and has application in many general cases. This function checks the element of the set one after the other and on the basis of a combination of results, it provides the output. The working of all() is a little bit tricky. Consider the case when we define a set with a particular data type and all function and then keeps that data type in the memory. Afterwards, it checks the result by following the sequence of combinations and then provides a single output in the form of true or false. The combination of all() is given in the table:
True |
False |
Result |
All values |
No value |
True |
No value |
All values |
False |
One value |
Remaining |
False |
Remaining |
One value |
False |
Empty set |
True |
|
Hence, just like the logical gates, the all() function works on the logics, and this will be proved when you see these examples:
Before going into the details of the all() function, have a look at the code where only integers anf floats are used with different values.
# integer set with non-zero values
myIntegerSet = {33,6,5,12,44,9}
print(all(myIntegerSet))
# Float and false value
myFloatSet = {33.6,55.9,12,4, False}
print(all(myFloatSet))
# Float with only one false value
FloatWithOneFalse = {1.8, 3.55, 4.34, False}
print(all(FloatWithOneFalse))
# Integer set with only one true value
integerWihOneTrueValue= {44,False,0}
print(all(integerWihOneTrueValue))
# empty set
emptySet={}
print(all(emptySet))
The following points are extracted from the results given above:
The digit zero is always considered false if you are using the float or integer sets.
The all() function checks each and every element and stores the results in memory, then checks for the combination and provides the results.
It is obvious that if the set contains the value "false,” then it will be considered the false function, and the compiler will not consider it a string.
The empty set is always true.
Now, this can also be performed with the string sets, and all the strings will be considered true. Hence, any element with double quotation marks will be considered a string, and the compiler will provide the output in the form of a single result.
Your task is to design the code using the information given above and check the results by matching the table given above.
If you have understood the previous function, then this will be more fun for you because, in some cases, we can say that the any() function is the opposite of the all() function. Therefore, they are named so. So, look at the code of the any() function, where only the name of the function is being replaced, and you will see the clear difference in the results.
# integer set with non-zero vlaues
myIntegerSet = {33,6,5,12,44,9}
print(any(myIntegerSet))
# Float and false value
myFloatSet = {33.6,55.9,12,4, False}
print(any(myFloatSet))
# Float with only one false value
FloatWithOneFalse = {1.8, 3.55, 4.34, False}
print(any(FloatWithOneFalse))
# Integer set with only one true value
integerWihOneTrueValue= {44,False,0}
print(any(integerWihOneTrueValue))
# empty set
emptySet={}
print(any(emptySet))
The results can easily be understood, and this time, we have extracted the table of combinations from the output of our code:
True |
False |
Result |
All values |
No value |
True |
No value |
All values |
False |
One value |
Remaining |
True |
Remaining |
One value |
True |
Empty set |
False |
|
So, the same task is for you as we have given the exercide with the all() function.
It is a different kind of function and is meant to represent the set in a better manner. While using it with the set, the output is obtained has the number of index with it automatically. It is useful in the long sets where the number of elements matters, and by using this, the programmer does not have to do the counting manually, but the index number is shown with each element. For this, the results are saved into the variable, and then the results are fed into the list. If it is confusing at the moment, have a look at the code given next:
#Making the set of books
Books={'Biology', 'Chemistry', 'Physics', 'English', 'General Knowledge',
'geography', 'poems', ' grammer','programming', 'software', 'technology'}
#declaring the varialbe
i=enumerate(Books)
#using the varialbe in list and printing the results
print(list(i))
So, all the books are arranged and have an index according to their position. Take the case into your mind, where the set contains hundreds or thousands of elements, and the indexing helps us to understand the collection.
The next function that is going to be discussed is the sorted() function, that plays an important role in the numeric calculations. Usually, programmers feed the data in an unordered manners.
If all the discussion above is not enough for you to understand the whole concept, then do not worry because these examples and their explanation will help you understand the concepts deeply.
It is a simple task, and the sorting is easy when you have few elements, but with the complex cases, the sorting needs logic. You will see some examples with the parameters in the same lecture, but for a start, have a look at the code below:
So, the sorting process of integers and
#Declaring the set
print("The unsorted set = ", myIntegers)
print()
#Using sorted() function on the set
print("The sorted set= ", sorted(myIntegers))
This is the big array, and it is difficult to arrange it manually; therefore, we are using sets here to eliminate the duplicate elements and to sort them with the help of a simple command.
Once the set is complete, it becomes difficult to read and understand the data of the set if it is large. In such cases, the sorted function is used, which sorts, or, in simpler words, arranges the data into a specific order. To learn about the syntax of this function, you must know three parameters:
This is the general term used to present a collection of things, groups, loops, or sequences. These are the necessary parts of the sorted function, and as “set” is the collection of data types, we can use it in this function to sort the elements according to our wishes. Without this parameter, the compiler will show the error.
It is a relatively difficult parameter to grasp, but it is responsible for the function's versatility. It may be tedious to realize that the set you are entering is only sorted in ascending and descending order. In programming, the data is stored in the form of different collections of numbers, and the key is the way to tell the compiler which pattern must be followed for sorting the data. This will be clear with the help of an example, and after that, we will examine the results:
The second parameter in the sorted() function is optional, and it is used to ask the programmer about the way to sort the data, that is if the programmer needs the iteration in an ascending or descending manner. It just has two possible inputs: true or false. As the name of the parameter indicates, if the reverse is set to true, the results will be in reverse order, that is, from the highest value to the lowest. But by default, it is always true, and if the programmer inputs true or even does not use this parameter, the output of the set will be in ascending rather than descending order.
# My string list declaration
mySet ={ ('apple'), ('red'), ('black'), ('strawberry')}
# sort set taking length as key and reversing the order
Result = sorted(mySet, key=len, reverse=True)
# print set
print('Sorted results:', Result)
So, it was an interesting tutorial on the sets, and with the help of different examples, we have learned built-in functions such as all(), any(), and the sorted function.
Hey, learners! Welcome to the next tutorial on Python with examples. We have been working with the collection of elements in different ways, and in the previous lecture, the topic was the built-in functions that were used with the sets in different ways. In the present lecture, we will pay heed to the basic operations of the set and their working in particular ways. We are making sure that each and every example is taken simply and easily, but the explanation is so clear that every user understands the concept and, at the same time, learns a new concept without any difficulty. The discussion will start after this short introduction of topics:
How do we declare and then find the difference between the two sets?
What are the built-in functions for operations, and how do we use them in the codes?
How do we apply the operation of symmetric differences on the sets?
What is chaining in iteration, and how do we use it? Give some examples.
How do you define the union of the sets?
What is an intersection and how it is related to the sets?
What is the procedure to find whether the sets are equal or not? Give us some examples in Python.
All of these are important interview questions, and we are using the concept in this lesson to find the answer to each question in detail. The Jupyter notebook is being used for practical work. To open it, go to the search bar in Windows and search for the Jupyter notebook. After that, go to the “new” dialogue box and start Python 3 to create a new notebook.
We all come from a programming background, and it is not surprising to know that different mathematical operations are used in programming to do useful tasks. In this lecture, you will learn the importance of mathematical functions with regard to sets. We have been working on the set since the last two lectures, and we are now aware of the details of working on sets. But during the programming process, the code contains different types of calculations, and large programs are extremely difficult to run without the involvement of mathematical operations. We will explain this with the help of different examples, and this is going to be fun because these concepts have been studied by us since our early education, and now is the time to know the reasons for that study.
This is the simplest set operation and it involves the difference between the elements of the set in their corresponding values. In simple words, if we are dealing with two sets named A and B then the difference between them is a new set containing all the elements that are in set A but not in set B. In Python, there are two ways to get the difference of the set in two ways:
The difference using the sign
The difference using the function
Both of these are discussed in detail here. The difference with the sign is simple as we minus the values in the simple mathematical question. A minus sign is used between the names of the set, and we get the result.
On the other hand, if we talk about the function, Python has a built-in function that calculates the difference, and it is a more professional way to use the functions for such operations. These two methods are simply described in the example given next:
#Declaring two sets
A={12,8,34,5,90,3,2}
B={1,7,90,33,2,1,5}
#Using both methods of difference
differenceWithSign=A-B
differenceWithFunction=(A.difference(B))
#Printing results
print("A-B= ",differenceWithSign)
print("Difference with function= ", differenceWithFunction)
It is obvious that both methods give us the same results. So it totally depends on the programmer to choose the method, but here is a reminder that the order of the names of sets is important here because if we write B-A then the results will be entirely different.
If you found the difference between the sets easy then you will find it more interesting because it is similar to the difference of the set but the only change is, in the resultant set, the uncommon elements of set A and B both are included instead of only the first set. In this way, the output of the entries from both the sets and no set is ignored. To denote the symmetric difference, the “^” sign is used. By the same token, the function for the symmetric difference also exists in Python,n and the keyword “symmetric_difference” is used for this. Have a look at the code and output for this case:
#Declaring two sets
A={12,8,34,5,90,3,2}
B={1,7,90,33,2,1,5}
#Using both methods of symmetric difference
SymmetricDifferenceWithSign=A^B
SymmetricDifferenceWithFunction=(A.symmetric_difference(B))
#Printing results
print("A^B= ",SymmetricDifferenceWithSign)
print("Difference with function= ", SymmetricDifferenceWithFunction)
Compare the results with the previous operation, and the difference will be clear.
In the previous lecture, we have been working with the itertools. The current case is to check whether the itertool works with the sets or not. You will see that the union of the two sets has the same results as the chain of the two sets, but for the sake of learning, we are working on both concepts. Hence, have a look at the code and understand it. After that, type the code on your own and check the results.
from itertools import chain
apple={12,8,34,5,90,3,2}
banana={1,7,90,33,2,1,5}
totalSales=set(chain(apple,banana))
print(totalSales)
By simply declaring and using the sets in a chain format, we are getting the result of the sales of both fruits, but in the cases where both sales were equal, the entry is ignored as we are using the set that ignores the duplicates.
At the simplest level, the results of union and chain are the same, but at a higher level, the working of both of these is different; therefore, it is important to understand both concepts and practice them with the sets.
Now, let us show you an interesting example of the same function where a set is used with the string entries. When applying the chain to that particular set, the same alphabets are ignored. The programmers can represent the results as joining or separate results, and this is explained well with the following code:
from itertools import chain
A = "Python"
B = "Programming"
C = "Tutorial"
output1 = set(chain(A, B, C))
print("before joining the set :", output1)
output2 = ''.join(res)
print("After joining the set :", output2)
We know the message is not conveyed in detail and therefore, it is proved that sets are more useful when dealing with numbers.
The name of this operation is self-explanatory if we have two sets named A and B, then the union of these sets means a new set that contains all the elements of set A and set B. We have read this in our mathematics classes, but here, this will be done with the help of coding. There are some special signs that are used to define the operations, just like we indicated the difference with the help of minus signs. When we talk about the union of the sets, we use the | sign for this, and Python also has the function for the union.
There is no need for long explanations for this operation, and we are simply changing the sign of the previous example and providing you with an example of how the difference and union give you entirely different results by changing just the operation.
#Declaring two sets
A={12,8,34,5,90,3,2}
B={1,7,90,33,2,1,5}
#Using both methods of Union
unionWithSign=A|B
unionWithFunction=(A.union(B))
#Printing results
print("A | B= ",unionWithSign)
print("Union with function= ", unionWithFunction)
As a result, the resultant set contains the values of both sets, but have you noticed that the resultant set has fewer values than the collection of both sets A and B? It is because we are using sets, and the values that are identical are just shown once.
If you have understood the concept of the union of sets, then you must keep it in mind, and then by comparing the process of intersection, the concept of both these operations will be clear in your mind. It is because usually people seem confused between these two.
Let us take the case where we are discussing the recipes of two dishes that are chicken and fish and want to know the common ingredients to write in the list. For this, we will use the intersection of the set, and both of these will contain the name of the ingredients, which means these are the string sets. During the process of the intersection of sets "fish” and "chicken," the resultant set contains all the elements that are common in both sets, and all other entries are totally ignored. In this way, the person will be able to understand what things he needs from the same section of the store and where he has to go for more shopping. This will be done with the help of the following code:
#Declaring two sets of string
fish={"Onion", "Tomato", "Garlic", "Fish", "Salt", "Carrot", "Eggs", "Ginger"}
chicken={"Chicken", "Salt", "Potato", "Onion", "Garlic", "pepper"}
#Using both methods of intersection
intersectionWithSign=fish & chicken
intersectionWithFunction=(fish.intersection(chicken))
#Printing results with the same ingredients
print("fish & chicken= ",intersectionWithSign)
print("Intersection with function= ", intersectionWithFunction)
When dealing with different types of sets, let's say set Apple and set Banana, where the shopkeeper stores the data of the weekly sales of cartons, the seller wants to take the record of the day and check if the sales are the same or not. Then, he simply checks the results by applying the equal signs for the two times between the sets and getting the result. Keep in mind that the order of the set does not matter here as the set does not have the index values. So, no matter if the sales were not equal on the same day, if the weekly sales are matching exactly, then the sets will be equal.
#Making the set of apples and banana with the sales
apple={34,78.9,32,89.7,33,12.6,55}
banana={12.6,78.9,33,34,32,89.7,55}
#using if loop to check the results and print the output
if apple==banana:
print("Sales of apple and banana are the same")
else:
print("Sales of apple and banana are not the same")
Now, to elaborate on this more, the sets that are used in the previous examples are fed into the same code, and then by running the code, we can conclude the results.
#Making the set with the sales
apple={12,8,34,5,90,3,2}
banana={1,7,90,33,2,1,5}
#using if loop to check the results and print the output
if apple==banana:
print("Sales of apple and banana are the same")
else:
print("Sales of apple and banana are not the same")
The “if” loop is an important iteration, and this is the best way to explain how we can use it for the bi-conditional cases. These loops will soon be used in many complex codes in this tutorial.
Hence, it was a fantastic tutorial on sets, and we learned a lot with the help of different operations. We had an idea about the sets and their characteristics, but in this lecture, the operations and working of the sets are well explained, and we see the difference, symmetric difference, chain, union, intersection, and equality operations of the sets in detail. I hope you get the point that we are trying to make clear. For more interesting tutorials, stay on the same website.